Memory

Live memory breakdown (Free/Inactive/Active/Wired) with allocation charts and history.

Overview

The Memory tool shows how your device's RAM is allocated, how much is readily reclaimable, and how the breakdown changes over time.

It is designed to answer practical questions like:

• "Is this device under memory pressure right now?"
• "Is memory being held by the system (wired), apps (active), or caches (inactive)?"
• "Is my memory usage stable over time, or spiking?"

In Lirum, Available Memory is the amount of memory that iOS can usually reclaim quickly: Free + Inactive.

Table of Contents

• Tabs
• Overview Tab
• Details Tab
• History Tab
• Memory States
• What iOS Does Under Pressure
• How To Interpret The Numbers
• Notes And Limitations

Tabs

• Overview
• Details
• History

Overview Tab

The Overview tab focuses on Available Memory:

• A circular gauge showing the available percentage.
• The available amount and the total RAM.
• A compact breakdown table: Free, Inactive, Active, Wired.

Use this view when you want a quick "is the device healthy right now?" read. If the four-row breakdown does not add up to Total, see Compressed and "Other".

Overview: Available Memory gauge plus the Free/Inactive/Active/Wired breakdown.

Details Tab

The Details tab provides a fuller breakdown:

• Memory Allocation chart (Active/Wired/Inactive/Free).
• Detailed Memory Information table with size and percentage.
• An Available row that combines Free + Inactive.

This is the best place to understand what kind of memory is being used (and whether it is likely to be reclaimed). If the percentages for Free/Inactive/Active/Wired do not sum to 100%, it is usually because some memory is currently accounted for as Compressed or "Other".

Details: allocation chart plus a detailed table with sizes and percentages.

History Tab

The History tab helps you understand trends instead of a single snapshot:

• Memory Allocation History: a stacked timeline for Free/Inactive/Active/Wired.
• Memory Usage History: a simplified view of overall usage over time.

Use History when:

• You suspect a leak or a runaway workload (usage rises steadily).
• You want to correlate stutters/app reloads with memory pressure (usage spikes then drops).
• You want to see if wired memory grows and stays high (often system/driver pressure).

History: see how memory allocation and overall usage change over time.

Memory States

Lirum uses the same high-level buckets iOS reports. These are the most useful "mental model" categories for iOS memory:

Bucket	What it usually means	Can iOS reclaim it quickly?
Free	Unused RAM, ready to allocate	Yes (already free)
Inactive	Mostly caches and pages not touched recently	Often
Active	Working set that is being used right now	Not directly
Wired	Pinned, non-pageable system memory	No
Compressed	Pages stored in the memory compressor	Not directly
Other	Remainder bucket (varies by OS/device)	It depends

Available (Free + Inactive)

Available is a practical "how much room do I have?" metric.

• Free: pages that are already unused.
• Inactive: mostly cache pages that can be dropped or repurposed when something else needs memory.

This is why Lirum shows Available = Free + Inactive in the Overview gauge and in the Details table.

Note: Available is not a guarantee that the system will instantly hand you that amount of memory without any cost. Reclaiming inactive pages can still involve work (dropping caches, writing back dirty pages, rebuilding cached data later).

What it means in practice:

• If Available is high and stable, the device generally has headroom, even if Free is low.
• If Available is consistently low (and stays low while you're doing normal tasks), iOS has less cache to reclaim and may start applying stronger pressure measures (compression, app termination).
• A short dip when opening an app is normal. A slow steady decline that does not recover is a common "pressure" pattern.

Wired

Wired memory is RAM that is pinned (non-pageable) and cannot be compressed or reclaimed on demand.

Think of Wired as "must stay resident" memory. It is usually owned by the kernel and low-level system services, and it is required for correctness or real-time behavior.

Typical examples:

• Kernel memory and core OS services
• Hardware drivers and DMA buffers
• Graphics/display surfaces and some GPU-related allocations
• Memory that must remain resident for real-time or correctness reasons

Why it matters:

• Wired memory is the least flexible bucket. If it grows large, iOS has fewer options to free RAM, so memory pressure increases sooner.
• A device can show low Free memory and still be fine, but consistently high Wired is harder for iOS to work around.

Common patterns:

• Wired can increase during camera usage, AR, games, video pipelines, heavy I/O, or when external accessories are in use.
• Wired tends to be "sticky". Some wired allocations do not shrink quickly, and some only reset after reboot.
• If Wired grows steadily over time and does not come back down, it can indicate sustained system-level pressure (or a leak in system services or drivers).

Active

Active memory is RAM that is currently being used (frequently referenced) by apps and the system.

Active is not just "app memory". It includes any pages the OS considers hot right now, including file-backed pages (for example, code and frameworks) and anonymous pages (for example, heaps and stacks).

Typical examples:

• App heaps and working sets
• In-use file caches and decoded media currently being used
• Data structures the system/app is actively touching

Why it matters:

• Active memory is not "wasted" memory; it's working memory. It will usually track whatever you're doing.
• iOS cannot simply "free" active pages without consequences. Under pressure, iOS typically tries to reclaim from caches first; if that is not enough, it may compress memory and eventually terminate apps.

Common patterns:

• Active usually rises as you open apps and do work, and it may fall when apps are terminated or when their pages become inactive over time.
• If Active keeps climbing while the workload is unchanged (or while the device is idle), it can be a hint of a memory leak or runaway cache in an app.

Inactive

Inactive memory is RAM that was recently used and is now mostly being kept as a cache.

Inactive is where iOS gets most of its "fast reclaim" headroom. A large portion of inactive memory is clean file cache that can be dropped and rebuilt later if needed.

Typical examples:

• Cached file pages
• Recently used app memory that can be repurposed
• Data that is not actively referenced but is kept around because it may become useful again

Why it matters:

• Inactive is usually the first place iOS will reclaim from when a new allocation needs RAM.
• High Inactive is often fine: it can mean iOS is using RAM efficiently as a cache.

Common patterns:

• Inactive often grows after app launches, reading files, scrolling media, or loading web content (those pages become cache).
• Under memory pressure, Inactive should drop as iOS repurposes cached pages for new allocations.
• If Inactive is already low and Available stays low, iOS has less "easy" memory to reclaim, and you can hit pressure sooner.

Free

Free memory is RAM that is currently unallocated and ready to use.

On iOS, Free is often low by design. The OS tries to keep RAM busy as cache so your next app launch, scroll, or file read is faster.

Why it matters:

• Free tends to be small on iOS even on healthy devices because iOS prefers to keep RAM working as cache (Inactive) rather than leaving it unused.
• Low Free alone is not a problem if Inactive is healthy and the device isn't under pressure.

Compressed and "Other" (why numbers may not add up)

In the app, iOS also reports additional memory buckets such as Compressed memory, plus other system allocations that do not fit cleanly into the four main page lists.

Compressed memory is RAM that iOS has compacted by storing pages in a compressed form. This is one of iOS's primary pressure relief mechanisms:

• Compression saves RAM, but it still uses RAM (and CPU to compress and decompress).
• A rising compressed footprint is often a signal that the system is working harder to avoid terminating apps.
• If a compressed page is accessed again, iOS must decompress it, which can add latency and increase CPU usage.

Other is a remainder bucket for everything not represented in the four main buckets. It can include various system allocations and VM accounting categories that iOS reports differently across OS versions and devices.

In Lirum:

• The Overview breakdown and the Details chart focus on the four most commonly interpreted states: Free, Inactive, Active, Wired.
• The Total memory shown is your device's physical RAM.

Because of that, the four-row breakdown may not sum exactly to Total on every device and OS version. The "missing" amount is typically memory currently accounted for as Compressed, plus miscellaneous system allocations (Other).

What iOS Does Under Pressure

When RAM gets tight, iOS typically applies pressure in stages:

• Reclaim caches first: repurpose Free pages, then reclaim Inactive caches (drop clean file cache, purge some caches).
• Compress memory: store less-recently-used pages in a compressed form to delay app termination.
• Terminate apps: if pressure continues, iOS may terminate background apps (and eventually foreground apps) to free memory. This often shows up as apps reloading when you switch back to them.

The Memory tool is most useful when you watch these stages happening over time using the History tab.

How To Interpret The Numbers

• Available (Free + Inactive) is the quickest "breathing room" metric.
• Wired is the hardest bucket to deal with. If Wired grows, the system has fewer knobs to turn.
• Inactive being large is often normal and good (cache). It should drop when the system needs memory.
• If Active + Wired grows and Available shrinks over time, you may see app reloads, stutters, or system pressure.
• Use the History tab to reason about trends. Single snapshots are easy to misread on iOS because the OS aggressively uses RAM for caching.
• If you see a steady decline in Available while you're doing something repeatable, that is a stronger indicator of an issue than any single number.

Notes And Limitations

• iOS manages memory automatically; seeing low Free memory is not always a problem by itself.
• Values and categories vary by device and OS, and update continuously while the tool is open.
• The Memory tool shows system-wide memory state (not per-app attribution).
• On some iPad models and OS versions, the system may use storage as swap. The Memory tool focuses on physical RAM and does not attempt to visualize swap usage.