diff --git a/launcher/Application.cpp b/launcher/Application.cpp
index 9268a8aef..cb8088be6 100644
--- a/launcher/Application.cpp
+++ b/launcher/Application.cpp
@@ -864,6 +864,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         m_metacache->addBase("ModpacksCHPacks", QDir("cache/ModpacksCHPacks").absolutePath());
         m_metacache->addBase("TechnicPacks", QDir("cache/TechnicPacks").absolutePath());
         m_metacache->addBase("FlamePacks", QDir("cache/FlamePacks").absolutePath());
+        m_metacache->addBase("FlameMods", QDir("cache/FlameMods").absolutePath());
         m_metacache->addBase("ModrinthPacks", QDir("cache/ModrinthPacks").absolutePath());
         m_metacache->addBase("root", QDir::currentPath());
         m_metacache->addBase("translations", QDir("translations").absolutePath());
diff --git a/launcher/net/HttpMetaCache.cpp b/launcher/net/HttpMetaCache.cpp
index 4d86c0b84..deb2780bb 100644
--- a/launcher/net/HttpMetaCache.cpp
+++ b/launcher/net/HttpMetaCache.cpp
@@ -121,6 +121,14 @@ auto HttpMetaCache::resolveEntry(QString base, QString resource_path, QString ex
         SaveEventually();
     }
 
+    // Get rid of old entries, to prevent cache problems
+    auto current_time = QDateTime::currentSecsSinceEpoch();
+    if (entry->isExpired(current_time - ( file_last_changed / 1000 ))) {
+        qWarning() << "Removing cache entry because of old age!";
+        selected_base.entry_list.remove(resource_path);
+        return staleEntry(base, resource_path);
+    }
+
     // entry passed all the checks we cared about.
     entry->basePath = getBasePath(base);
     return entry;
@@ -221,6 +229,8 @@ void HttpMetaCache::Load()
         foo->etag = Json::ensureString(element_obj, "etag");
         foo->local_changed_timestamp = Json::ensureDouble(element_obj, "last_changed_timestamp");
         foo->remote_changed_timestamp = Json::ensureString(element_obj, "remote_changed_timestamp");
+        foo->current_age = Json::ensureDouble(element_obj, "current_age");
+        foo->max_age = Json::ensureDouble(element_obj, "max_age");
         // presumed innocent until closer examination
         foo->stale = false;
 
@@ -240,6 +250,8 @@ void HttpMetaCache::SaveNow()
     if (m_index_file.isNull())
         return;
 
+    qDebug() << "[HttpMetaCache]" << "Saving metacache with" << m_entries.size() << "entries";
+
     QJsonObject toplevel;
     Json::writeString(toplevel, "version", "1");
 
@@ -259,6 +271,8 @@ void HttpMetaCache::SaveNow()
             entryObj.insert("last_changed_timestamp", QJsonValue(double(entry->local_changed_timestamp)));
             if (!entry->remote_changed_timestamp.isEmpty())
                 entryObj.insert("remote_changed_timestamp", QJsonValue(entry->remote_changed_timestamp));
+            entryObj.insert("current_age", QJsonValue(double(entry->current_age)));
+            entryObj.insert("max_age", QJsonValue(double(entry->max_age)));
             entriesArr.append(entryObj);
         }
     }
diff --git a/launcher/net/HttpMetaCache.h b/launcher/net/HttpMetaCache.h
index e944b3d5d..df3549e82 100644
--- a/launcher/net/HttpMetaCache.h
+++ b/launcher/net/HttpMetaCache.h
@@ -64,6 +64,14 @@ class MetaEntry {
     auto getMD5Sum() -> QString { return md5sum; }
     void setMD5Sum(QString md5sum) { this->md5sum = md5sum; }
 
+    auto getCurrentAge() -> qint64 { return current_age; }
+    void setCurrentAge(qint64 age) { current_age = age; }
+
+    auto getMaximumAge() -> qint64 { return max_age; }
+    void setMaximumAge(qint64 age) { max_age = age; }
+
+    bool isExpired(qint64 offset) { return current_age >= max_age - offset; };
+
    protected:
     QString baseId;
     QString basePath;
@@ -72,6 +80,8 @@ class MetaEntry {
     QString etag;
     qint64 local_changed_timestamp = 0;
     QString remote_changed_timestamp;  // QString for now, RFC 2822 encoded time
+    qint64 current_age = 0;
+    qint64 max_age = 0;
     bool stale = true;
 };
 
diff --git a/launcher/net/MetaCacheSink.cpp b/launcher/net/MetaCacheSink.cpp
index f86dd8704..ab0c9fcb5 100644
--- a/launcher/net/MetaCacheSink.cpp
+++ b/launcher/net/MetaCacheSink.cpp
@@ -36,11 +36,16 @@
 #include "MetaCacheSink.h"
 #include <QFile>
 #include <QFileInfo>
-#include "FileSystem.h"
 #include "Application.h"
 
 namespace Net {
 
+/** Maximum time to hold a cache entry
+ *  = 1 week in seconds
+ */
+#define MAX_TIME_TO_EXPIRE 1*7*24*60*60
+
+
 MetaCacheSink::MetaCacheSink(MetaEntryPtr entry, ChecksumValidator * md5sum)
     :Net::FileSink(entry->getFullPath()), m_entry(entry), m_md5Node(md5sum)
 {
@@ -88,6 +93,37 @@ Task::State MetaCacheSink::finalizeCache(QNetworkReply & reply)
     }
 
     m_entry->setLocalChangedTimestamp(output_file_info.lastModified().toUTC().toMSecsSinceEpoch());
+
+    { // Cache lifetime
+        if (reply.hasRawHeader("Cache-Control")) {
+            auto cache_control_header = reply.rawHeader("Cache-Control");
+            // qDebug() << "[MetaCache] Parsing 'Cache-Control' header with" << cache_control_header;
+
+            QRegularExpression max_age_expr("max-age=([0-9]+)");
+            qint64 max_age = max_age_expr.match(cache_control_header).captured(1).toLongLong();
+            m_entry->setMaximumAge(max_age);
+
+        } else if (reply.hasRawHeader("Expires")) {
+            auto expires_header = reply.rawHeader("Expires");
+            // qDebug() << "[MetaCache] Parsing 'Expires' header with" << expires_header;
+
+            qint64 max_age = QDateTime::fromString(expires_header).toSecsSinceEpoch() - QDateTime::currentSecsSinceEpoch();
+            m_entry->setMaximumAge(max_age);
+        } else {
+            m_entry->setMaximumAge(MAX_TIME_TO_EXPIRE);
+        }
+
+        if (reply.hasRawHeader("Age")) {
+            auto age_header = reply.rawHeader("Age");
+            // qDebug() << "[MetaCache] Parsing 'Age' header with" << age_header;
+
+            qint64 current_age = age_header.toLongLong();
+            m_entry->setCurrentAge(current_age);
+        } else {
+            m_entry->setCurrentAge(0);
+        }
+    }
+
     m_entry->setStale(false);
     APPLICATION->metacache()->updateEntry(m_entry);