Milap

Nirav Desai

WP Power Cache is designed for developers and site owners who need extreme speed without the bloat of traditional caching plugins. It converts your dynamic WordPress pages into static HTML files, serving them directly from the filesystem to bypass heavy PHP and MySQL processing.
Key Features:
Core Performance & Caching 
* Static HTML Generation: Automatically creates, minifies, and stores HTML snapshots for optimized, lightweight output. 
* Smart Cache Clearing: Intelligently invalidates only specific post cache and the homepage upon updates to maintain efficiency. 
* Cache TTL/Expiration System: Provides fine-grained control over cache lifetimes to ensure content freshness. 
* Advanced URL Exclusion: Supports both regex and string-based exclusions for precise caching control. 
* Modern Lazy Loading: Enhances page speed with high-performance asset loading and zero jQuery dependency.
Developer & Admin Tools 
* Developer Mode & Performance Metrics: Dedicated real-time monitoring tools to track and optimize site performance. 
* Admin Bar Integration: Provides the ability to clear the full site cache directly from the WordPress admin bar. 
* Enhanced System Diagnostics: Built-in checks for permissions, disk space, and permalink compatibility with advanced debugging insights. 
* Full Audit Logging: Complete transparency with tracking for all cache activity and administrative actions.
Security & Architecture 
* Secure Storage & Protection: Utilizes hashed directories and directory traversal protection to prevent unauthorized file access.

WP Power Cache


Excellent caching plugin! Very easy to set up and it significantly improved my website’s loading speed. The interface is clean and the performance improvements are noticeable.


Simple and Powerful Caching Plugin

A high-performance static page caching engine that generates HTML snapshots of your WordPress site for near-instant loading times.

Lukas Rydygel

Jinx Fast-Cache provides a simple but highly efficient way to implement full-page caching. It generates static HTML files of your pages, which are then served directly by your web server (Apache or Nginx).
By bypassing the entire PHP process and database queries, your server load is significantly reduced and your website response time becomes near-instant. Unlike many other plugins, Jinx Fast-Cache is built with a developer-first approach, working primarily with URLs and offering deep integration via filters and actions.
<h3>Usage</h3>
<h3>Server Configuration</h3>
To serve the cached files directly, you must add rewrite rules to your server configuration.
For Apache (.htaccess): 
The plugin will attempt to modify your <code>.htaccess</code> automatically. If it fails, add this manually:
<pre><code># BEGIN Jinx Fast-Cache
RewriteEngine On
RewriteBase /
RewriteCond %{DOCUMENT_ROOT}/wp-content/jinx-fast-cache/%{HTTP_HOST}/%{REQUEST_URI}/%{QUERY_STRING}/index.html -s
RewriteCond %{REQUEST_METHOD} GET
RewriteRule .* /wp-content/jinx-fast-cache/%{HTTP_HOST}/%{REQUEST_URI}/%{QUERY_STRING}/index.html [L]
# END Jinx Fast-Cache
</code></pre>
For Nginx: 
Add the following logic to your server block:
<pre><code>set $cache_path false;
if ($request_method = GET) {
 set $cache_path /wp-content/jinx-fast-cache/$host/$uri/$args/index.html;
}
location / {
 try_files $cache_path $uri $uri/ /index.php?$query_string;
}
</code></pre>
<h3>Cache Management</h3>
<ul>
<li>Admin Bar: You can flush (clear), warm (generate), or refresh (flush & warm) single or multiple URLs directly from the admin bar.</li>
<li>Automatic Updates: Posts are automatically “warmed” after saving and “flushed” when deleted or set to draft.</li>
<li>Background Processing: The warming process uses a background queue handled via WordPress Cron to ensure server stability. Single post warming skips the queue for immediate results.</li>
<li>Plugin Updates: The cache is automatically refreshed after the plugin is updated.</li>
</ul>
<h3>Developer API</h3>
Jinx Fast-Cache is highly extensible. While a settings panel is available, developers can fine-tune every detail via filters and actions.
<h3>1. Filters</h3>
<ul>
<li>jinx_fast_cache_active: Toggle caching for specific conditions (default: false).</li>
<li>jinx_fast_cache_post_types: Define which post types should be cached (default: ‘page’ and ‘publicly_queryable’ types).</li>
<li>jinx_fast_cache_posts: Filter the specific list of post objects to be cached.</li>
<li>jinx_fast_cache_taxonomies: Define which taxonomies are cacheable.</li>
<li>jinx_fast_cache_terms: Filter the specific list of terms to be cached.</li>
<li>jinx_fast_cache_output: Modify the raw HTML content before it is saved to the cache file.</li>
<li>jinx_fast_cache_minify: Enable/disable HTML minification (default: false).</li>
<li>jinx_fast_cache_flush: Define additional related URLs that should be cleared when a specific page is flushed.</li>
<li>jinx_fast_cache_warm: Define additional related URLs that should be preloaded when a specific page is warmed.</li>
<li>jinx_fast_cache_queue_interval: Adjust the cron task frequency for the warming queue (default: 60s).</li>
<li>jinx_fast_cache_queue_size: Adjust the batch size per cron task (default: 10). Set to <code><= 0</code> to process everything at once (Caution: High server load).</li>
<li>jinx_fast_cache_gc_interval: Adjust the Garbage Collector frequency to remove invalid files (default: 60s).</li>
<li>jinx_fast_cache_ignore_logged_in_users: Toggle caching for logged-in users (default: true).</li>
<li>jinx_fast_cache_ignore_404: Toggle if 404 error pages should be cached (default: false).</li>
<li>jinx_fast_cache_query_params: Define allowed query parameters. Return <code>__return_empty_array</code> to ignore all parameters.</li>
<li>jinx_fast_cache_refresh_on_upgrade: Toggle the full cache refresh after plugin updates (default: true).</li>
<li>jinx_fast_cache_ttl: Define the cache lifetime (TTL). Supports seconds (e.g., 3600) or strings (e.g., ’12 hours’, ‘1 week’).</li>
</ul>
<h3>2. Dynamic Injections (AJAX)</h3>
Since static HTML files cannot execute PHP, Jinx allows you to “inject” dynamic content (like a user’s name or a shopping cart) via AJAX.
Injecting a Template Part:
<pre><code>do_action('jinx_fast_cache_inject_template', 'template-slug', 'Placeholder text...');
</code></pre>
Injecting via Function Call:
You can call any public function or class method:
<pre><code>do_action('jinx_fast_cache_inject', 'date', ['Y']);
do_action('jinx_fast_cache_inject', ['MyClass', 'myMethod'], [$arg1, $arg2]);
</code></pre>
Using Shortcodes:
<pre><code>[jinx_fast_cache_inject placeholder="Loading..."] Your dynamic content here [/jinx_fast_cache_inject]
</code></pre>
JS Callbacks:
Trigger custom JavaScript after the content has been injected:
<pre><code>$('.element').on('jinx-fast-cache-inject', (e) => { /* Handle injection */ });
element.addEventListener('jinx-fast-cache-inject', (e) => { /* Handle injection */ }, false);
</code></pre>
<h3>3. URL Tags & Relations</h3>
Tags are a powerful way to link multiple URLs together. If one URL is flushed, all other URLs sharing the same tag will also be purged. This is perfect for linking a “Latest Posts” widget on your homepage to your single post entries.
Via Shortcode:
<pre><code>[jinx_fast_cache tags="news,homepage"]
</code></pre>
Via Action:
<pre><code>do_action('jinx_fast_cache', ['tags' => 'tag1,tag2']);
do_action('jinx_fast_cache', ['tags' => ['tag1', 'tag2']]);
</code></pre>
<h3>4. Per-Page Cache Duration (TTL)</h3>
Override the global TTL for specific high-traffic or highly dynamic pages.
Via Shortcode:
<pre><code>[jinx_fast_cache ttl="3600"] or `[jinx_fast_cache ttl="12 hours"]`
</code></pre>
Via Action:
<pre><code>do_action('jinx_fast_cache', ['ttl' => 3600]);
</code></pre>
Combined Call (Tags + TTL):
<pre><code>do_action('jinx_fast_cache', ['ttl' => 3600, 'tags' => ['foo', 'bar']]);<h3>Roadmap</h3>
</code></pre>
– [x] Release the plugin 
– [x] Add HTML minification for output 
– [x] Allow injection of dynamic rendered templates using ajax requests 
– [x] Add taxonomies 
– [x] Provide scheduled tasks 
– [x] Add admin columns for cache status 
– [x] Provide exclude option for posts and terms in backend 
– [x] Add multisite support 
– [x] Flush and warm after update complete 
– [x] Add possibility to ignore 404 
– [x] Allow query params to be excluded or totally ignored 
– [x] Provide cache duration 
– [x] Provide admin panel to change options 
– [x] Add tags to flush related pages 
– [x] Add shortcode for injects 
– [x] Add JS events for injects 
– [x] Gutenberg inject block

Jinx Fast-Cache

Blazing fast full-page caching for WordPress. Jinx Fast-Cache serves static HTML files, bypassing PHP and database overhead entirely.

WP Power Cache vs Jinx Fast-Cache