Open a modern JavaScript site in a browser and you see the full page. Look at the HTML the server actually sends and it can be almost empty: a shell and a script tag. Browsers run the script and fill in the content. Many crawlers, link preview fetchers and AI bots don’t, so they see the empty shell. The text you wrote never reaches them.
RenderCache fixes that on your own server. It’s a self-hosted pre-render cache: one Go binary, plus Chrome, that sits in front of your existing app. It renders your public pages in Chrome ahead of time, warms them from your sitemap, and hands the saved HTML to crawler requests. Regular visitors still get the normal app.
The Pitch in Four Words
The project sums itself up in four words, and they’re the clearest way in.
- Warm. Sitemap discovery and scheduled renders keep every listed page ready before a crawler asks.
- Cached. Saved pages are served without starting a browser, and expired copies stay available while a fresh one renders in the background.
- Logged. Every crawler response gets a receipt, bypasses included, so you can see what each bot was actually sent.
- Yours. Snapshots and delivery logs stay on your server, with rotating logs and quotas.
How It Works
RenderCache reads your sitemap and queues renders for pages that are missing or out of date. Chrome runs as a separate process, waits for a readiness selector or a settling delay, and captures the finished page. The snapshot keeps structured data, strips out executable scripts and inline event handlers, and includes content from open shadow roots and same-origin frames, so pages built from web components aren’t blank for crawlers.
When a crawler asks, there are three outcomes. A fresh copy is a HIT and is served straight from disk. An expired copy is served as STALE while one deduplicated refresh runs in the background. A page that’s never been rendered is a MISS: the request goes to your app as usual and a render is queued, so the crawler never waits for Chrome. Redirects and 404 or 410 responses are kept, and validators like 304 work.
It’s careful with private content. Cookies, authorization headers, APIs, assets and unusual methods all bypass the shared snapshots. Render jobs never inherit a visitor’s cookies or login. If a page turns out private, starts setting cookies or answers 401 or 403, the old shared copy is withdrawn. Ordinary render failures keep the older snapshot and retry with backoff.
User agents are only claims. With crawler verification turned on, a request that says it’s Googlebot, GPTBot or ClaudeBot must come from that operator’s published addresses, or it gets the live app. Receipts record whether the address checked out, along with the path, status, cache outcome, snapshot age, bytes sent and duration.
RenderCache can run as the reverse proxy itself, or sit behind an existing edge that routes crawler traffic to it. It builds for Linux, macOS and Windows, and the Dockerfile installs Chrome for you.
Who It’s For
- Teams running public JavaScript apps whose content needs to reach search engines and AI crawlers.
- Sites whose link previews come out blank on social networks and chat apps.
- Companies that don’t want a third-party rendering service seeing their pages and their bot traffic.
- Anyone who wants proof of what each crawler was actually sent.
Limits
It’s an early release meant for evaluation. Chrome is a separate dependency, and its memory, processes and temp files need limits set by the operating system or container. It’s for public, unauthenticated pages only. Receipts show what was sent, not whether a search engine indexed it or whether a user agent was genuine unless verification was on. Before using it on a live site, check the readiness selector, snapshot coverage and crawler responses.
The Four-Question Screening
Every project featured here gets the same four questions, the way you’d screen a startup idea.
1. Where is the money in it?
The engine is open source under Apache 2.0, with no paid tier. Pre-rendering is an established paid service, usually priced per page and run by a third party. RenderCache’s angle is self-hosting, which appeals to companies that care about privacy, cost at scale or control. The paid paths are a commercial support plan, a managed deployment, and reporting on AI crawler traffic, which is growing fast and which site owners increasingly want to see and steer.
2. What real problem does it solve?
Content that crawlers can’t see. A JavaScript app can look perfect in the browser and be close to invisible to bots that don’t run scripts, which hurts search, previews and how AI assistants read the site.
3. The technology in plain words
Imagine a shop whose window display is assembled by a robot every time someone looks. Most people wait and see it. Some passers-by only glance, and see an empty window. RenderCache takes a photo of the finished display every so often and holds it up for the people who only glance, while everyone else still sees the robot do its thing.
4. Moat and differentiation
Hosted pre-render services are the incumbents. RenderCache keeps everything on your own server, verifies crawler identity against published addresses, handles private pages conservatively and logs exactly what each bot got. That combination fits companies that won’t hand their pages to a third party. The moat that can grow is the careful edge-case handling, which is most of the real work in pre-rendering, and visibility into AI crawler traffic.
Why It Matters
More of the web is read by machines now, from search engines to AI assistants. If those readers see an empty shell, the content might as well not exist. A self-hosted cache that shows them the real page, and proves it, keeps a site visible.
Follow the Project
Read how it works, try the demo, follow the quickstart and deployment guide, check the status and roadmap, or get the code from the RenderCache repository on GitHub. RenderCache is listed with the other open-source projects on SoftDevStudio.com, and more featured projects are in the Projects section.