Recommended Free Tools
WordPress caching is not one switch. It is a set of separate layers that save different kinds of work: complete HTML pages, static browser assets, database-backed objects, and compiled PHP bytecode. A good setup usually starts with page caching for public pages, adds correct browser headers, confirms PHP OPcache, and then considers persistent object caching such as Redis or Memcached when the site is database-heavy.
Antihost offers managed WordPress hosting with free migration, one-click staging and a 14-day free trial.
The important limit is safety: a cached response must not be shown to the wrong user. Logged-in pages, carts, checkouts, account screens, permission-sensitive content, and other personalized responses need exclusions or carefully designed vary rules.
As an Amazon Associate I earn from qualifying purchases.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →What WordPress caching does
A normal WordPress request can involve the web server, PHP, WordPress core, plugins, theme code, and several database queries before the visitor receives HTML. Caching keeps the result of one or more expensive stages so the next request can reuse it.
The layer determines what is reused. A page cache can return an already-rendered HTML document without running most of WordPress. An object cache can reuse a query result while PHP still builds the response. Browser caching can prevent the visitor from downloading the same stylesheet or image again. Opcode caching lets PHP reuse compiled bytecode instead of repeatedly reading and compiling source files.
#1 Best Overall
These layers can work together, but they are not interchangeable. WordPress’s cache handbook describes caching as a major performance improvement and notes that static-file caching can, in suitable fairly static cases, improve performance “several hundred times over.” That is a qualitative example, not a universal benchmark: results depend on traffic, hosting, page complexity, cache-hit rate, and invalidation behavior.
The four WordPress cache layers
| Layer | What it stores | Where it runs | Best use | What to compare |
|---|---|---|---|---|
| Page cache | A complete rendered HTML response | A plugin, web server, reverse proxy, or CDN | Repeated requests for public pages | Hit rate, purge rules, and dynamic-page exclusions |
| Browser cache | CSS, JavaScript, images, fonts, and other static assets | The visitor’s browser, controlled by HTTP headers | Reducing repeat downloads | Cache-Control/Expires policy and invalidation |
| Object cache | Query results and application objects | WordPress runtime or a backend such as Redis or Memcached | Database-heavy sites and repeated object reads | Persistence across requests, memory capacity, and backend latency |
| Opcode cache | Compiled PHP bytecode | The PHP runtime on the server | Avoiding repeated PHP compilation | PHP version, allocated memory, and invalidation behavior |
A site may have all four layers enabled and still be misconfigured. For example, a page cache can serve stale HTML while the browser has a fresh-looking stylesheet, or an object cache can retain an old option while page files have already been purged.
Free tools Windows power users keep installed
One-click scans. No signup required.
Page caching: the largest win for public content
Page caching saves the final HTML generated for a URL. On a cache hit, the server can deliver that file or response without repeating much of the PHP execution and database work. This is why it is usually the first cache layer to configure for a brochure site, blog, documentation site, or other site where many visitors see the same public content.
What belongs in a page cache
- Public posts, pages, archives, and landing pages whose output is the same for most visitors.
- Rendered HTML that does not contain a user-specific name, permission check, cart state, or session-dependent result.
- Responses for which you have a known purge rule when content, templates, menus, or settings change.
What must be excluded or varied
- Logged-in dashboards and account pages.
- Cart, checkout, payment, and order-confirmation screens.
- Forms or pages whose output changes with a session, cookie, role, subscription, location, or other request state.
- Any endpoint that displays private data or accepts a state-changing request.
Some pages can be partly cached: a public article may be cached while a small user-specific fragment is loaded separately. That design requires deliberate rules. Do not assume a plugin’s default exclusions cover every custom endpoint added by a theme or extension.
Choosing one page-cache owner
Use one clearly identified page-cache implementation: a host-level cache, a reverse proxy or CDN, or a WordPress caching plugin. Overlapping systems can each write files, add headers, and purge different stores. The result is difficult to diagnose because one layer may continue serving an old response after another layer has been cleared.
Before enabling a second system, identify where HTML is stored, which component serves a cache hit, and how a publish or update event triggers purging. If those answers are not clear, leave the existing page cache in control and add other layers independently.
Browser caching: headers for static assets
Browser caching does not save a WordPress page on the server. It tells a visitor’s browser how long it may reuse a CSS file, JavaScript file, image, font, or other static response. The server communicates this policy with headers such as Cache-Control and Expires.
Set a policy by asset stability
- Versioned assets: files whose URL changes when content changes can receive a long reuse period, because a new filename or query version causes a new request.
- Frequently edited assets: use a shorter policy or a reliable revalidation strategy so a correction is not hidden in a visitor’s browser.
- HTML: handle separately from images, stylesheets, scripts, and fonts; page-cache rules and browser rules solve different problems.
Headers alone are not an invalidation plan. If a stylesheet keeps the same URL after an edit, visitors may continue using the old copy until its policy allows revalidation. Change the asset filename or version when your build or deployment process changes its contents, and purge any intermediary CDN or proxy cache that also stores it.
Object caching: reusing WordPress data
WordPress’s WP_Object_Cache class avoids repeated database trips and stores computationally expensive results during request processing. By default, this object cache is non-persistent: its contents last only for the current request and disappear when that request ends.
What persistent object caching changes
A persistent object-cache integration keeps eligible objects available across requests. Redis and Memcached are common backends documented for this purpose. They are separate services or server components, so WordPress needs the relevant backend, PHP extension or client support, and an object-cache drop-in such as a compatible Redis, Memcached, SQLite, or other integration.
“Persistent” here means persistent across web requests, not guaranteed permanent storage on disk. Entries can still expire, be evicted when memory is full, or be flushed during maintenance. Plan capacity and recovery accordingly.
When object caching is worth considering
- The site performs many repeated reads of options, terms, post metadata, or other objects.
- Database latency or connection limits are a visible bottleneck even after public pages are served efficiently.
- The host provides a supported Redis or Memcached service with enough memory and a compatible WordPress integration.
- Logged-in or otherwise dynamic traffic forms a substantial share of requests, so a page cache cannot help every response.
Object caching is not required for every WordPress installation and does not replace page caching. A page cache can avoid building a public response at all; an object cache accelerates the work that still has to run.
Rank #3
Developer-facing object-cache functions
Plugin and theme developers should use WordPress’s wp_cache_* functions rather than calling the cache class directly. Common operations include:
wp_cache_get()to retrieve a value.wp_cache_set()to store a value.wp_cache_delete()to remove a value.wp_cache_flush()to clear the cache when a full flush is justified.
Choose stable, specific cache keys and define sensible expiration or invalidation behavior in the code that changes the underlying data. A persistent backend makes mistakes last beyond one request, so stale-key handling matters more after installation.
Transients are not automatically memory-backed
WordPress transients use the available object-cache behavior, but without persistent object caching they can be stored in the database, commonly in the wp_options table. Do not assume that creating a transient always avoids a database write or read. Verify the active object-cache integration before treating transients as an in-memory performance feature.
Opcode caching: let PHP reuse compiled code
PHP OPcache stores compiled PHP bytecode in server memory. On later requests, PHP can reuse that compiled representation instead of reading and compiling the same source files repeatedly. This is independent of WordPress page and object caches.
Confirm that OPcache is enabled by the hosting or server administrator and that its memory and invalidation settings match the deployment process. After changing PHP files, an opcode cache that has not recognized the change can make the old code appear to remain active. The correct reset or reload procedure depends on the PHP runtime and hosting stack, so use the host’s documented method rather than deleting WordPress page-cache files and assuming every layer was cleared.
What WP_CACHE does—and does not do
WP_CACHE is commonly associated with page-cache drop-ins, but it is not a universal caching switch. Defining it does not, by itself, install or configure Redis, Memcached, browser cache headers, PHP OPcache, or a page-cache system.
The WordPress configuration documentation distinguishes page caching through an advanced-cache.php drop-in, object caching through an object-cache.php drop-in, PHP opcode caching, and browser caching through HTTP headers or a CDN. Persistent object caching and page caching are separate systems. Enabling a constant without the corresponding drop-in and server component therefore produces no complete caching setup.
A safe setup sequence
Configure layers in an order that keeps ownership and testing clear.
- Map the hosting stack. Identify whether the host, web server, reverse proxy, CDN, or an existing plugin already caches HTML. Record where cache files or entries live and how purges are triggered.
- Choose one page-cache implementation. Enable HTML caching for public responses, then define exclusions for authentication, sessions, carts, checkout, permissions, and other personalized output.
- Test public and private URLs separately. Check a logged-out public page, a logged-in page, and every transactional flow before broad rollout. Confirm that private content is never returned from a shared cache.
- Set browser headers for stable assets. Apply
Cache-Controland, where appropriate,Expirespolicies to CSS, JavaScript, images, and fonts. Pair long-lived policies with filename or version invalidation. - Confirm PHP OPcache. Verify that the server’s PHP runtime is using OPcache and that deployments invalidate changed scripts correctly.
- Add persistent object caching only when justified. Install the supported backend, PHP extension or client, and WordPress drop-in. Check memory limits, eviction behavior, and a documented flush method.
- Document purge ownership. Write down how to clear page files, object entries, browser-facing CDN copies, and opcode state. Purge only the affected layer when possible; use a full flush when a schema, deployment, or broad data change requires it.
- Recheck after every configuration change. Test as an anonymous visitor, a logged-in user, and a user with any relevant role or session state. Confirm both fresh content and protected content.
Purging and invalidation by layer
| Visible problem | Likely layer | Appropriate first action |
|---|---|---|
| A published page still shows old HTML to anonymous visitors | Page cache or reverse proxy/CDN | Purge the affected URL or page-cache group, then request it again as a logged-out visitor. |
| A changed stylesheet or image is old only in one browser | Browser cache | Use a new asset version or filename and verify the response headers. |
| Dynamic code reads an old option or query result | Object cache | Invalidate the relevant key or flush the object cache if the change is broad. |
| Edited PHP code appears unchanged everywhere | Opcode cache | Use the hosting stack’s PHP reload or OPcache invalidation procedure. |
| One cache clears but stale content remains | Multiple layers | Trace which component served the response and purge that component rather than assuming WordPress handled every store. |
A purge is not a substitute for correct exclusions. If a personalized response was cached and shared, clearing it removes the current copy but does not prevent the next unsafe cache hit.
How to verify each layer
Verify page caching
- Request the same public URL twice while logged out and compare the response behavior and headers exposed by your stack.
- Publish a harmless content edit, perform the documented purge, and confirm that anonymous visitors receive the new HTML.
- Log in and verify that the response changes appropriately without exposing another user’s data.
Verify browser caching
- Inspect the response headers for CSS, JavaScript, images, and fonts.
- Change an asset through the normal build or versioning process and confirm that the URL changes or revalidation occurs.
Verify object caching
- Confirm that the expected
object-cache.phpintegration is active and that the backend is reachable. - Observe cache hits, misses, memory use, and evictions using the host or backend’s monitoring tools.
- Change a value that should invalidate a key and verify that the next request does not read the old value.
Verify OPcache
Deploy a controlled PHP change and use the server’s supported status or reload procedure to confirm that the new code is compiled and served. Do not infer OPcache state from a page-cache purge.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Common mistakes and their fixes
Using WP_CACHE as an on switch
Why it fails: the constant does not install a page cache or backend. Fix: install and configure the appropriate drop-in and server component, then test the actual response path.
Running overlapping page caches
Why it fails: each layer may generate different files, headers, and purge events. Fix: appoint one page-cache owner and document how any upstream proxy or CDN is purged.
Best Value
- Offer contains ONLY 2 titles regardless of the order quantity placed for this listing. Set of volumes may vary. Ordering in multiples will not change the volume received. Image is meant to display the type of book you will be receiving only.
- BRAIN TEASING. Perfect Puzzle Book for all ages to learn. Enjoy puzzles, maze, word search, or crosswords! This puzzle book is ideal for people on the go and will provide hours of entertainment.
- FUN & CHALLENGING. Exercise your brains long-term memory, working memory, executive functioning, attention to detail, multitasking, and processing speed. Perfect gifting item for those who love word search puzzles!
- RELAX, RECHARGE, & REFOCUS. The word find puzzle book offers an enjoyable challenge for all, from beginners to experts. Ideal for learning, practicing, and having fun time for various users.
- OFFICIALLY LICENSED. High-resolution printing. Perfect for family activities, classroom learning, or travel. Provide an engaging, educational experience with every page, making it both fun and meaningful.
Expecting object caching to replace page caching
Why it fails: object caching speeds repeated data reads but still leaves PHP, theme, and plugin execution. Fix: use page caching for identical public HTML and object caching for work that must remain dynamic.
Caching private or transactional responses
Why it fails: a shared cache cannot safely serve output that varies by user, session, role, cart, or order. Fix: exclude those routes or implement carefully tested vary and fragment rules.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteAssuming a transient is always in memory
Why it fails: without a persistent object cache, transients may live in the database, commonly in wp_options. Fix: check the active backend and design for the storage actually available.
Purging the wrong layer
Why it fails: stale HTML, stale assets, stale objects, and stale bytecode have different owners. Fix: identify the serving layer from the request path and clear that layer using its supported procedure.
Which layers does a site actually need?
Small public site
Start with one page cache for public pages, sensible browser headers for static assets, and the host’s normal OPcache. Add persistent object caching only if profiling or hosting guidance shows repeated database work that page caching cannot avoid.
Busy content site
Use page caching with reliable purge events for posts, archives, menus, and templates. Add browser versioning and monitor cache-hit behavior. Persistent object caching can help logged-in traffic, search, widgets, and other requests that still execute WordPress.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCommerce or membership site
Treat personalization and transaction state as the design constraint. Cache only genuinely public responses, keep account and checkout flows excluded, and test every role, cookie, cart, and payment transition. Object and opcode caching may still accelerate dynamic execution, but neither makes a private response safe to share.
Development and deployment environments
Use short or disabled page-cache policies when rapid edits matter, and document how to invalidate OPcache after code deployment. Re-enable production policies only after checking that asset versioning, page purges, and private-route exclusions are part of the release process.
Operational checklist
- One documented owner for page-cache generation and purge.
- Explicit exclusions for logged-in, session-dependent, permission-sensitive, cart, checkout, and account responses.
- Browser policies matched to asset versioning and deployment.
- OPcache enabled and included in the code-deployment runbook.
- Persistent object caching installed only with a supported backend, extension, drop-in, and memory plan.
- Separate verification for anonymous, authenticated, and transactional requests.
- A recovery procedure for page files, object entries, browser-facing caches, and compiled PHP.
- Monitoring for stale content, cache evictions, memory pressure, backend failures, and unexpected cache misses.
The practical model is simple: cache the broadest response that is truly identical, and stop at the boundary where user or request state changes the output. Treat each cache as a separate system with its own data, owner, invalidation method, and failure mode.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
