diff --git a/.gitignore b/.gitignore
index 7cee265..a2a94b2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,4 +2,6 @@ __pycache__
 env
 target
 Cargo.lock
-.idea
\ No newline at end of file
+.idea
+cdn
+cache
diff --git a/hashes/hashes.py b/hashes/hashes.py
index 4d0ede4..0a2d6cc 100644
--- a/hashes/hashes.py
+++ b/hashes/hashes.py
@@ -15,18 +15,4 @@ hash_list = [
     "polysexual penguin",
     "aromantic armadillo",
     "queer quokka",
-]
-
-LOREM_IPSUM_COMMENTS = [
-    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.",
-    "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
-    "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo.",
-    "Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet.",
-    "At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias excepturi sint occaecati cupiditate non provident, similique sunt in culpa.",
-    "gay furry pride >:3 OwO get rekt Charlie Kirk",
-    "Et harum quidem rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus, omnis voluptas assumenda est, omnis dolor repellendus.",
-    "Temporibus autem quibusdam et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a sapiente delectus, ut aut reiciendis voluptatibus maiores alias.",
-    "Nulla facilisi. Cras vehicula aliquet libero, sit amet lacinia nunc commodo eu. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae.",
-    "Proin euismod, nisl sit amet ultricies lacinia, nisl nisl aliquam nisl, eget aliquam nisl nisl sit amet nisl. Sed euismod, nisl sit amet ultricies lacinia, nisl nisl aliquam nisl, eget aliquam nisl nisl sit amet nisl.",
-    "Vivamus euismod, nisl sit amet ultricies lacinia, nisl nisl aliquam nisl, eget aliquam nisl nisl sit amet nisl. Sed euismod, nisl sit amet ultricies lacinia, nisl nisl aliquam nisl, eget aliquam nisl nisl sit amet nisl."
 ]
\ No newline at end of file
diff --git a/hashes/obfuscation/Obfuscator.py b/hashes/obfuscation/Obfuscator.py
deleted file mode 100644
index 30a219c..0000000
--- a/hashes/obfuscation/Obfuscator.py
+++ /dev/null
@@ -1,131 +0,0 @@
-import random
-import re
-
-from hashes.hashes import LOREM_IPSUM_COMMENTS
-
-class Obfuscator:
-    def obfuscate_html(html_content):
-        # Generate random strings
-        def generate_random_string(length=8):
-            chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
-            return ''.join(random.choice(chars) for _ in range(length))
-        
-        # Protect original content
-        protected_blocks = []
-        
-        def protect_scripts(match):
-            protected_blocks.append(match.group(0))
-            return f'<!-- PROTECTED_SCRIPT_{len(protected_blocks)-1} -->'
-        
-        def protect_styles(match):
-            protected_blocks.append(match.group(0))
-            return f'<!-- PROTECTED_STYLE_{len(protected_blocks)-1} -->'
-        
-        # First pass: protect critical content
-        temp_html = re.sub(r'<script[^>]*>.*?</script>', protect_scripts, html_content, flags=re.DOTALL)
-        temp_html = re.sub(r'<style[^>]*>.*?</style>', protect_styles, temp_html, flags=re.DOTALL)
-        
-        # Protect tables
-        def protect_tables(match):
-            protected_blocks.append(match.group(0))
-            return f'<!-- PROTECTED_TABLE_{len(protected_blocks)-1} -->'
-        
-        temp_html = re.sub(r'<table[^>]*>.*?</table>', protect_tables, temp_html, flags=re.DOTALL)
-        
-        # Clean up HTML - remove extra whitespace
-        lines = []
-        for line in temp_html.split('\n'):
-            cleaned_line = ' '.join(line.split())
-            if cleaned_line:
-                lines.append(cleaned_line)
-        
-        # Add comments between lines (but not too many)
-        obfuscated_lines = []
-        
-        for i, line in enumerate(lines):
-            # Add comment before some lines
-            if line and not line.startswith('<!--') and random.random() > 0.7:
-                lorem_comment = random.choice(LOREM_IPSUM_COMMENTS)
-                obfuscated_lines.append(f'<!-- {lorem_comment} -->')
-            
-            obfuscated_lines.append(line)
-            
-            # Add comment after some lines  
-            if line and not line.startswith('<!--') and random.random() > 0.8:
-                lorem_comment = random.choice(LOREM_IPSUM_COMMENTS)
-                obfuscated_lines.append(f'<!-- {lorem_comment} -->')
-        
-        obfuscated = '\n'.join(obfuscated_lines)
-        
-        # Inject random comments between SOME elements (not all)
-        def inject_some_comments(html):
-            # Only inject between certain safe elements
-            safe_patterns = [
-                (r'(</div>)', r'\1<!--' + generate_random_string(6) + '-->'),
-                (r'(</p>)', r'\1<!--' + generate_random_string(6) + '-->'),
-                (r'(</span>)', r'\1<!--' + generate_random_string(6) + '-->'),
-                (r'(</h1>)', r'\1<!--' + generate_random_string(6) + '-->'),
-                (r'(</h2>)', r'\1<!--' + generate_random_string(6) + '-->'),
-                (r'(</h3>)', r'\1<!--' + generate_random_string(6) + '-->'),
-            ]
-            
-            for pattern, replacement in safe_patterns:
-                if random.random() > 0.5:  # 50% chance to apply each pattern
-                    html = re.sub(pattern, replacement, html)
-            
-            return html
-        
-        obfuscated = inject_some_comments(obfuscated)
-        
-        # Add header comments (fewer to avoid breaking the document)
-        header_comments = [
-            'auto-obfuscated-' + generate_random_string(10),
-            'generated-' + generate_random_string(8),
-        ]
-        
-        header_block = '\n'.join([f'<!-- {comment} -->' for comment in header_comments])
-        obfuscated = header_block + '\n' + obfuscated
-        
-        # Add footer comments
-        footer_comments = [
-            'end-' + generate_random_string(10),
-            'completed-' + generate_random_string(8),
-        ]
-        
-        footer_block = '\n'.join([f'<!-- {comment} -->' for comment in footer_comments])
-        obfuscated = obfuscated + '\n' + footer_block
-        
-        # Minimal invisible characters - only in text content, not in tags
-        invisible_chars = ['\u200B', '\u200C']
-        
-        def add_minimal_invisible(match):
-            text = match.group(1)
-            # NEVER obfuscate script-like content
-            if any(keyword in text for keyword in ['function', 'const ', 'var ', 'let ', 'document.', 'window.', 'getElement', 'querySelector', 'addEventListener']):
-                return '>' + text + '<'
-            
-            # Only add to plain text content
-            if len(text) > 10:  # Only on longer text blocks
-                result = []
-                for i, char in enumerate(text):
-                    result.append(char)
-                    # Very rarely add invisible chars
-                    if i % 8 == 0 and i > 0 and random.random() > 0.8:
-                        result.append(random.choice(invisible_chars))
-                return '>' + ''.join(result) + '<'
-            
-            return '>' + text + '<'
-        
-        obfuscated = re.sub(r'>([^<]+)<', add_minimal_invisible, obfuscated)
-        
-        # Restore protected content exactly as-is
-        for i, protected_content in enumerate(protected_blocks):
-            obfuscated = obfuscated.replace(f'<!-- PROTECTED_SCRIPT_{i} -->', protected_content)
-            obfuscated = obfuscated.replace(f'<!-- PROTECTED_STYLE_{i} -->', protected_content)
-            obfuscated = obfuscated.replace(f'<!-- PROTECTED_TABLE_{i} -->', protected_content)
-        
-        # Final cleanup - ensure no double newlines and remove extra spaces
-        obfuscated = re.sub(r'\n\n+', '\n', obfuscated)
-        obfuscated = re.sub(r'[ \t]+', ' ', obfuscated)  # Remove extra spaces and tabs
-        
-        return obfuscated
\ No newline at end of file
diff --git a/html/base/template.html b/html/base/template.html
index ed2743b..70332f2 100644
--- a/html/base/template.html
+++ b/html/base/template.html
@@ -7,20 +7,29 @@
     <link rel="stylesheet" href="../css/main.css">
     <link rel="icon" type="image/x-icon" href="../css/favicon/favicon.ico">
     <script src="../js/post/download.js" defer></script>
-
+    
     <!-- Prism.js CSS theme -->
-    <link rel="preload" href="https://cdn.jsdelivr.net/npm/prismjs/themes/prism.min.css" rel="stylesheet" />
+    <!--<link rel="preload" href="https://cdn.jsdelivr.net/npm/prismjs/themes/prism.min.css" rel="stylesheet" />-->
 
     <!-- Prism.js core + languages -->
+    <!--
     <script rel="preload" src="https://cdn.jsdelivr.net/npm/prismjs/prism.min.js"></script>
     <script rel="preload" src="https://cdn.jsdelivr.net/npm/prismjs/components/prism-python.min.js"></script>
     <script rel="preload" src="https://cdn.jsdelivr.net/npm/prismjs/components/prism-javascript.min.js"></script>
-
+    -->
 
     <!-- MathJAX for LaTeX Support -->
+    <!--
     <script rel="preload" src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" id="MathJax-script"></script>
+    -->
 
-    <!-- remove if causing issues -->
+    <!-- Locally fetch the CDN -->
+    <link rel="stylesheet" href="/package/css/prism.min.css" />
+    <script rel="preload" src="/package/js/prism.min.js"></script>
+    <script rel="preload" src="/package/js/prism-python.min.js"></script>
+    <script rel="preload" async defer src="/package/js/mathjax.js"></script>
+
+        <!-- remove if causing issues -->
     <script src="../js/post/lazyimg.js"></script>
     <script src="../js/shared/theme.js"></script>
     <style>
@@ -30,10 +39,10 @@
 <body style="display:flex; flex-direction:column; min-height:100%; margin:0;">
 <main class="container" style="flex:1;">
     <h1 onclick="window.location.href=window.location.origin" style="cursor:pointer; display:flex; align-items:center; gap:8px; font-size:1.5em; margin:0;">
-        <img src="../css/icons/back.webp" width="32" height="32" alt="⬅" style="display:block;" />
+        <img loading="lazy" src="../css/icons/back.webp" width="32" height="32" alt="⬅" style="display:block;" />
         {{ title }}  <noscript>(Enable JavaScript!)</noscript>
     </h1>
-    <img src="../css/icons/written.webp" width="32" height="32" alt="📄" loading="lazy" style="vertical-align: middle;padding-left:40px;cursor:pointer;" onclick="toggleDarkMode();" />
+    <img loading="lazy" src="../css/icons/written.webp" width="32" height="32" alt="📄" loading="lazy" style="vertical-align: middle;padding-left:40px;cursor:pointer;" onclick="toggleDarkMode();" />
     <div class="meta" style="display: inline;cursor:pointer;" onclick="toggleDarkMode();">
         Written @{{ now }}
     </div>
diff --git a/lua/plugins/examples/post.lua b/lua/plugins/examples/demo/post.lua
similarity index 100%
rename from lua/plugins/examples/post.lua
rename to lua/plugins/examples/demo/post.lua
diff --git a/markdown/Rotation.md b/markdown/Rotation.md
index 99e4eb1..1032589 100644
--- a/markdown/Rotation.md
+++ b/markdown/Rotation.md
@@ -192,4 +192,9 @@ Der Punkt wurde damit um die x-Achse um 45° gedreht.
 * Es gibt drei Grundmatrizen: $R_x(\theta)$, $R_y(\theta)$ und $R_z(\theta)$.
 * Durch **Multiplikation** kann man mehrere Drehungen kombinieren.
 * Die Reihenfolge der Rotationen ist **nicht vertauschbar**.
-* Bei $45^\circ$ erscheinen häufig die Werte $\frac{\sqrt{2}}{2}$ und $\frac{1}{2}$.
\ No newline at end of file
+* Bei $45^\circ$ erscheinen häufig die Werte $\frac{\sqrt{2}}{2}$ und $\frac{1}{2}$.
+
+```python
+def hello() -> str:
+    return "Hello"
+```
\ No newline at end of file
diff --git a/webserver.py b/webserver.py
index 43fd960..a9225fb 100644
--- a/webserver.py
+++ b/webserver.py
@@ -5,8 +5,12 @@ import subprocess
 from http.server import BaseHTTPRequestHandler, HTTPServer
 import mimetypes
 import json
-from jsmin import jsmin  # pip install jsmin
+from jsmin import jsmin 
 from pathlib import Path
+import requests
+from functools import lru_cache
+import hashlib
+from typing import Optional, Tuple
 
 from log.Logger import *
 from lua import plugin_manager
@@ -14,13 +18,136 @@ from PyPost import extract_summary
 
 logger = Logger()
 plugin_manager = plugin_manager.PluginManager()
-plugin_manager.load_all() # load all plugins
+plugin_manager.load_all()
 
 PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
 HTML_DIR = os.path.join(PROJECT_ROOT, "html")
 MARKDOWN_DIR = os.path.join(PROJECT_ROOT, "markdown")
 BASE_FILE = os.path.join(HTML_DIR, "base", "index.html")
 LUA_DIR = Path(PROJECT_ROOT) / "lua" / "plugins"
+CACHE_DIR = os.path.join(PROJECT_ROOT, "cache")
+CDN_CACHE_DIR = os.path.join(CACHE_DIR, "cdn")
+
+# CDN Resources to fetch and cache
+CDN_RESOURCES = {
+    "/package/css/prism.min.css": "https://cdn.jsdelivr.net/npm/prismjs/themes/prism.min.css",
+    "/package/js/prism.min.js": "https://cdn.jsdelivr.net/npm/prismjs/prism.min.js",
+    "/package/js/prism-python.min.js": "https://cdn.jsdelivr.net/npm/prismjs/components/prism-python.min.js",
+    "/package/js/prism-javascript.min.js": "https://cdn.jsdelivr.net/npm/prismjs/components/prism-javascript.min.js",
+    "/package/js/mathjax.js": "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js",
+}
+
+# CDN base URLs for dynamic resource fetching
+CDN_BASES = {
+    "mathjax": "https://cdn.jsdelivr.net/npm/mathjax@3/es5"
+}
+
+# File extensions to cache aggressively
+CACHEABLE_EXTENSIONS = {'.css', '.js', '.webp', '.jpg', '.jpeg', '.png', '.gif', '.svg', '.woff', '.woff2', '.ttf', '.eot', '.ico'}
+
+def ensure_cache_dirs():
+    """Ensure cache directories exist"""
+    os.makedirs(CDN_CACHE_DIR, exist_ok=True)
+    logger.log_info(f"Cache directory ready: {CDN_CACHE_DIR}")
+
+def fetch_cdn_resources():
+    """Fetch all CDN resources on startup and cache them"""
+    ensure_cache_dirs()
+    logger.log_info("Fetching CDN resources...")
+    
+    for local_path, cdn_url in CDN_RESOURCES.items():
+        try:
+            # Create filename from hash of URL for safe storage
+            url_hash = hashlib.md5(local_path.encode()).hexdigest()
+            cache_file = os.path.join(CDN_CACHE_DIR, url_hash)
+            
+            # Check if already cached
+            if os.path.exists(cache_file):
+                logger.log_debug(f"CDN resource already cached: {local_path}")
+                continue
+            
+            # Fetch resource
+            logger.log_info(f"Fetching {cdn_url}...")
+            response = requests.get(cdn_url, timeout=30)
+            response.raise_for_status()
+            
+            # Save to cache
+            with open(cache_file, 'wb') as f:
+                f.write(response.content)
+            
+            logger.log_info(f"Cached CDN resource: {local_path} ({len(response.content)} bytes)")
+            
+        except Exception as e:
+            logger.log_error(f"Failed to fetch CDN resource {cdn_url}: {e}")
+
+def fetch_cdn_resource_on_demand(local_path: str) -> Optional[bytes]:
+    """
+    Fetch a CDN resource on-demand if not already cached.
+    Used for dynamically loaded resources like MathJax dependencies.
+    """
+    # Try to map the request to a known CDN base
+    if local_path.startswith("/package/js/"):
+        relative_path = local_path[12:]  # Remove "/package/js/"
+        
+        # MathJax resources
+        if any(x in relative_path for x in ["a11y/", "input/", "output/", "ui/", "sre"]):
+            cdn_url = f"{CDN_BASES['mathjax']}/{relative_path}"
+        else:
+            return None
+        
+        try:
+            url_hash = hashlib.md5(local_path.encode()).hexdigest()
+            cache_file = os.path.join(CDN_CACHE_DIR, url_hash)
+            
+            # Check cache first
+            if os.path.exists(cache_file):
+                with open(cache_file, 'rb') as f:
+                    return f.read()
+            
+            # Fetch from CDN
+            logger.log_info(f"Fetching on-demand: {cdn_url}")
+            response = requests.get(cdn_url, timeout=10)
+            response.raise_for_status()
+            
+            # Cache it
+            with open(cache_file, 'wb') as f:
+                f.write(response.content)
+            
+            logger.log_info(f"Cached on-demand: {local_path}")
+            return response.content
+            
+        except Exception as e:
+            logger.log_error(f"Failed to fetch on-demand resource {cdn_url}: {e}")
+            return None
+    
+    return None
+
+@lru_cache(maxsize=1024)
+def load_file_cached(file_path: str, is_js: bool = False) -> Tuple[bytes, str]:
+    """
+    LRU cached file loader for static assets.
+    Returns (content, mime_type)
+    """
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type is None:
+        mime_type = "application/octet-stream"
+    
+    with open(file_path, "rb") as f:
+        content = f.read()
+    
+    # Minify JS files
+    if is_js or mime_type == "application/javascript" or file_path.endswith(".js"):
+        try:
+            content = jsmin(content.decode("utf-8")).encode("utf-8")
+        except Exception as err:
+            logger.log_error(f"Error minifying JS file {file_path}: {err}")
+    
+    return content, mime_type
+
+def should_cache_file(file_path: str) -> bool:
+    """Determine if a file should be LRU cached based on extension"""
+    ext = os.path.splitext(file_path)[1].lower()
+    return ext in CACHEABLE_EXTENSIONS
 
 def get_html_files(directory=HTML_DIR):
     html_files = []
@@ -68,9 +195,9 @@ def build_index_page() -> str:
     return base_html.replace("<!-- CONTENT -->", full_content)
 
 
-
 import base64
 import random
+import time
 
 from hashes.hashes import hash_list
 
@@ -79,7 +206,6 @@ H1 = random.choice(hash_list)
 H2_CANDIDATES = [h for h in hash_list if h != H1]
 H2 = random.choice(H2_CANDIDATES) if H2_CANDIDATES else H1
 
-# cahcing was a bad, idea, servertime got stuck. it is now a variable ;)
 def index_footer() -> str:
     tor_link = "http://7uhuxits7qfmiagkmpazxvh3rtk6aijs6pbawge3fl77y4xqjixlhkqd.onion/"
     return f"""
@@ -108,71 +234,66 @@ def index_footer() -> str:
 """
 
 class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
-    # This is a Helper Function for the POST Endpoints
     def _parse_post_data(self):
-            """Parse POST request body"""
-            import json
-            content_length = int(self.headers.get('Content-Length', 0))
-            if content_length == 0:
-                return {}
-            
-            post_data = self.rfile.read(content_length)
-            content_type = self.headers.get('Content-Type', '')
-            
-            try:
-                if 'application/json' in content_type:
-                    return json.loads(post_data.decode('utf-8'))
-                elif 'application/x-www-form-urlencoded' in content_type:
-                    from urllib.parse import parse_qs
-                    parsed = parse_qs(post_data.decode('utf-8'))
-                    return {k: v[0] if len(v) == 1 else v for k, v in parsed.items()}
-                else:
-                    return {"raw": post_data}
-            except Exception as e:
-                logger.log_error(f"Error parsing POST data: {e}")
+        """Parse POST request body"""
+        import json
+        content_length = int(self.headers.get('Content-Length', 0))
+        if content_length == 0:
+            return {}
+        
+        post_data = self.rfile.read(content_length)
+        content_type = self.headers.get('Content-Type', '')
+        
+        try:
+            if 'application/json' in content_type:
+                return json.loads(post_data.decode('utf-8'))
+            elif 'application/x-www-form-urlencoded' in content_type:
+                from urllib.parse import parse_qs
+                parsed = parse_qs(post_data.decode('utf-8'))
+                return {k: v[0] if len(v) == 1 else v for k, v in parsed.items()}
+            else:
                 return {"raw": post_data}
+        except Exception as e:
+            logger.log_error(f"Error parsing POST data: {e}")
+            return {"raw": post_data}
 
     def do_POST(self):
-            """Handle POST requests - primarily for plugin routes"""
-            req_path = self.path.lstrip("/")
-            
-            # Parse POST data
-            post_data = self._parse_post_data()
-            
-            # Add additional request info
-            request_data = {
-                "path": self.path,
-                "headers": dict(self.headers),
-                "data": post_data,
-                "method": "POST"
-            }
-            
-            # Check plugin routes
-            plugin_result = plugin_manager.handle_request("/" + req_path, request_data, method="POST")
-            if plugin_result is not None:
-                status, headers, body = plugin_result
-                self.send_response(status)
-                for key, value in headers.items():
-                    self.send_header(key, value)
-                self.end_headers()
-                
-                if isinstance(body, str):
-                    self.wfile.write(body.encode("utf-8"))
-                elif isinstance(body, bytes):
-                    self.wfile.write(body)
-                else:
-                    self.wfile.write(str(body).encode("utf-8"))
-                return
-            
-            # No plugin handled this POST request
-            self.send_response(404)
-            self.send_header("Content-type", "application/json")
+        """Handle POST requests - primarily for plugin routes"""
+        req_path = self.path.lstrip("/")
+        
+        post_data = self._parse_post_data()
+        
+        request_data = {
+            "path": self.path,
+            "headers": dict(self.headers),
+            "data": post_data,
+            "method": "POST"
+        }
+        
+        plugin_result = plugin_manager.handle_request("/" + req_path, request_data, method="POST")
+        if plugin_result is not None:
+            status, headers, body = plugin_result
+            self.send_response(status)
+            for key, value in headers.items():
+                self.send_header(key, value)
             self.end_headers()
-            error_response = json.dumps({"error": "Route not found"})
-            self.wfile.write(error_response.encode("utf-8"))
+            
+            if isinstance(body, str):
+                self.wfile.write(body.encode("utf-8"))
+            elif isinstance(body, bytes):
+                self.wfile.write(body)
+            else:
+                self.wfile.write(str(body).encode("utf-8"))
+            return
+        
+        self.send_response(404)
+        self.send_header("Content-type", "application/json")
+        self.end_headers()
+        error_response = json.dumps({"error": "Route not found"})
+        self.wfile.write(error_response.encode("utf-8"))
 
     def do_GET(self):
-        req_path = self.path.lstrip("/")  # normalize leading /
+        req_path = self.path.lstrip("/")
 
         # Handle root/index
         if req_path == "" or req_path == "index.html":
@@ -183,7 +304,52 @@ class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
             self.wfile.write(content.encode("utf-8"))
             return
 
-        # CHECK PLUGIN ROUTES FIRST
+        # Handle CDN package requests
+        if req_path.startswith("package/"):
+            cdn_path = "/" + req_path
+            
+            # Try to get from pre-fetched cache
+            if cdn_path in CDN_RESOURCES:
+                url_hash = hashlib.md5(cdn_path.encode()).hexdigest()
+                cache_file = os.path.join(CDN_CACHE_DIR, url_hash)
+                
+                if os.path.exists(cache_file):
+                    with open(cache_file, 'rb') as f:
+                        cached_content = f.read()
+                else:
+                    cached_content = None
+            else:
+                # Try on-demand fetching for dynamic resources
+                cached_content = fetch_cdn_resource_on_demand(cdn_path)
+            
+            if cached_content:
+                # Determine mime type
+                if cdn_path.endswith('.css'):
+                    mime_type = "text/css"
+                elif cdn_path.endswith('.js'):
+                    mime_type = "application/javascript"
+                elif cdn_path.endswith('.wasm'):
+                    mime_type = "application/wasm"
+                elif cdn_path.endswith('.json'):
+                    mime_type = "application/json"
+                else:
+                    mime_type = "application/octet-stream"
+                
+                self.send_response(200)
+                self.send_header("Content-type", mime_type)
+                self.send_header("Cache-Control", "public, max-age=86400")
+                self.send_header("Access-Control-Allow-Origin", "*")  # CORS for CDN resources
+                self.end_headers()
+                self.wfile.write(cached_content)
+                return
+            else:
+                logger.log_warning(f"CDN resource not found: {cdn_path}")
+                self.send_response(404)
+                self.end_headers()
+                self.wfile.write(b"404 - CDN resource not available")
+                return
+
+        # CHECK PLUGIN ROUTES
         plugin_result = plugin_manager.handle_request("/" + req_path, {"path": self.path})
         if plugin_result is not None:
             status, headers, body = plugin_result
@@ -196,9 +362,8 @@ class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
 
         # Handle markdown file downloads
         if req_path.startswith("markdown/"):
-            markdown_filename = req_path[9:]  # Remove "markdown/" prefix
+            markdown_filename = req_path[9:]
             
-            # Security check
             if not markdown_filename.endswith(".md") or ".." in markdown_filename or "/" in markdown_filename:
                 self.send_response(403)
                 self.end_headers()
@@ -242,9 +407,8 @@ class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
 
         # Handle Lua file downloads
         if req_path.startswith("lua/"):
-            lua_filename = req_path[4:]  # Remove "lua/" prefix
+            lua_filename = req_path[4:]
 
-            # Security check
             if not lua_filename.endswith(".lua") or ".." in lua_filename or "/" in lua_filename:
                 self.send_response(403)
                 self.end_headers()
@@ -286,7 +450,7 @@ class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
                 self.wfile.write(b"500 - Internal Server Error")
                 return
 
-        # Handle other files (existing functionality)
+        # Handle other files with LRU caching for static assets
         file_path = os.path.normpath(os.path.join(PROJECT_ROOT, req_path))
         if not file_path.startswith(PROJECT_ROOT):
             self.send_response(403)
@@ -295,25 +459,46 @@ class WebServerHTTPRequestHandler(BaseHTTPRequestHandler):
             return
 
         if os.path.isfile(file_path):
-            mime_type, _ = mimetypes.guess_type(file_path)
-            if mime_type is None:
-                mime_type = "application/octet-stream"
+            try:
+                # Use LRU cache for cacheable files
+                if should_cache_file(file_path):
+                    is_js = file_path.endswith('.js')
+                    content, mime_type = load_file_cached(file_path, is_js)
+                    
+                    self.send_response(200)
+                    self.send_header("Content-type", mime_type)
+                    self.send_header("Cache-Control", "public, max-age=3600")  # Cache for 1 hour
+                    self.end_headers()
+                    self.wfile.write(content)
+                else:
+                    # Non-cacheable files (e.g., HTML)
+                    mime_type, _ = mimetypes.guess_type(file_path)
+                    if mime_type is None:
+                        mime_type = "application/octet-stream"
 
-            with open(file_path, "rb") as f:
-                content = f.read()
+                    with open(file_path, "rb") as f:
+                        content = f.read()
 
-            # Obfuscate JS on the fly
-            if mime_type == "application/javascript" or file_path.endswith(".js"):
-                try:
-                    content = jsmin(content.decode("utf-8")).encode("utf-8")
-                except Exception as err:
-                    logger.log_error(f"Error minifying JS file {file_path}: {err}")
+                    # Minify JS even if not cached
+                    if mime_type == "application/javascript" or file_path.endswith(".js"):
+                        try:
+                            content = jsmin(content.decode("utf-8")).encode("utf-8")
+                        except Exception as err:
+                            logger.log_error(f"Error minifying JS file {file_path}: {err}")
 
-            self.send_response(200)
-            self.send_header("Content-type", mime_type)
-            self.end_headers()
-            self.wfile.write(content)
-            return
+                    self.send_response(200)
+                    self.send_header("Content-type", mime_type)
+                    self.end_headers()
+                    self.wfile.write(content)
+                
+                return
+                
+            except Exception as err:
+                logger.log_error(f"Error serving file {file_path}: {err}")
+                self.send_response(500)
+                self.end_headers()
+                self.wfile.write(b"500 - Internal Server Error")
+                return
 
         self.send_response(404)
         self.end_headers()
@@ -327,12 +512,19 @@ def run_pypost():
 
 if __name__ == "__main__":
     try:
+        # Fetch CDN resources on startup
+        logger.log_info("Initializing CDN resource cache...")
+        fetch_cdn_resources()
+        logger.log_info("CDN resources ready!")
+        
+        # Start PyPost watcher
         threading.Thread(target=run_pypost, daemon=True).start()
         logger.log_debug("Started PyPost.py in background watcher thread.")
 
         server_address = ("localhost", 8000)
-        httpd: HTTPServer = HTTPServer(server_address, WebServerHTTPRequestHandler) # type: ignore[arg-type]
+        httpd: HTTPServer = HTTPServer(server_address, WebServerHTTPRequestHandler)
         logger.log_info(f"Serving on http://{server_address[0]}:{server_address[1]}")
+        logger.log_info(f"LRU cache enabled for static assets (max 512 files)")
         httpd.serve_forever()
     except (Exception, KeyboardInterrupt) as e:
         logger.log_info(f"Shutting down server.\n Reason: {e}")