diff --git a/example/content/2025-08-03-multi-site-support.md b/example/content/2025-08-03-multi-site-support.md
new file mode 100644
index 0000000..a2185aa
--- /dev/null
+++ b/example/content/2025-08-03-multi-site-support.md
@@ -0,0 +1,71 @@
+---
+title: Multi-Site Support in Marmite
+slug: multi-site-support
+tags: features, docs, content-organization
+author: rochacbruno
+---
+
+# Multi-Site Support in Marmite
+
+Marmite now supports generating multiple independent sites from a single project! This feature allows you to create subsites with their own themes, configurations, and search indexes.
+
+## How it works
+
+Any directory inside your `content` folder that contains a `site.yaml` file will be processed as a subsite. Each subsite:
+
+- Has its own independent configuration
+- Can use a different theme
+- Maintains a separate search index  
+- Is served at its own URL path (e.g., `/site1/`)
+
+## Creating a subsite
+
+1. Create a directory in your content folder:
+   ```bash
+   mkdir content/site1
+   ```
+
+2. Add a `site.yaml` configuration file:
+   ```yaml
+   name: My Subsite
+   theme: theme_template
+   enable_search: true
+   ```
+
+3. Add content files (markdown) to the subsite directory
+
+4. Build your site as usual - Marmite will automatically detect and process the subsite
+
+## Example structure
+
+```
+example/
+├── marmite.yaml          # Main site config
+├── content/
+│   ├── posts.md         # Main site content
+│   └── site1/
+│       ├── site.yaml    # Subsite config
+│       ├── about.md     # Subsite content
+│       └── posts.md     # More subsite content
+└── site/                # Generated output
+    ├── index.html       # Main site
+    └── site1/
+        └── index.html   # Subsite at /site1/
+```
+
+## Configuration inheritance
+
+Subsites inherit certain configuration values from the parent site if not specified:
+
+- Theme selection
+- Date format settings
+- Other default values
+
+## Use cases
+
+- Documentation sites with versioned content
+- Multi-language sites
+- Separate blogs or sections with different themes
+- Project portfolios with independent sections
+
+This feature enables complex site architectures while maintaining Marmite's simplicity and performance.
\ No newline at end of file
diff --git a/example/content/site1/2025-01-01-post.md b/example/content/site1/2025-01-01-post.md
new file mode 100644
index 0000000..cb6adb3
--- /dev/null
+++ b/example/content/site1/2025-01-01-post.md
@@ -0,0 +1,29 @@
+---
+title: Welcome to Site1
+tags: subsite, announcement
+author: Site1 Admin
+---
+
+# Welcome to Site1
+
+This is the first post on our independent subsite! This site has its own theme, configuration, and search index.
+
+## What makes this subsite special?
+
+- Independent theme configuration (using theme_template)
+- Separate search index
+- Own URL space at `/site1/`
+- Isolated content management
+
+### Testing features
+
+This subsite demonstrates Marmite's multi-site capabilities.
+
+![A photo of a Bruno](./media/bruno.jpg)
+
+
+### A photo from the main site
+
+Using `../` to go up one level to the main site.
+
+![A photo of marmite](../media/marmite.jpg)
\ No newline at end of file
diff --git a/example/content/site1/about.md b/example/content/site1/about.md
new file mode 100644
index 0000000..d134b4f
--- /dev/null
+++ b/example/content/site1/about.md
@@ -0,0 +1,3 @@
+# Hello from site1
+
+This is a test of the site1
\ No newline at end of file
diff --git a/example/content/site1/media/bruno.jpg b/example/content/site1/media/bruno.jpg
new file mode 100644
index 0000000..252c320
Binary files /dev/null and b/example/content/site1/media/bruno.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/gallery.yaml b/example/content/site1/media/gallery/site1photos/gallery.yaml
new file mode 100644
index 0000000..8058db4
--- /dev/null
+++ b/example/content/site1/media/gallery/site1photos/gallery.yaml
@@ -0,0 +1,3 @@
+name: "Site 1 Photos"
+ord: asc
+cover: "window.jpg"
diff --git a/example/content/site1/media/gallery/site1photos/palms.jpg b/example/content/site1/media/gallery/site1photos/palms.jpg
new file mode 100644
index 0000000..bb3146f
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/palms.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/passage.jpg b/example/content/site1/media/gallery/site1photos/passage.jpg
new file mode 100644
index 0000000..9a3834f
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/passage.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/pool.jpg b/example/content/site1/media/gallery/site1photos/pool.jpg
new file mode 100644
index 0000000..7677f33
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/pool.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/sunflower.jpg b/example/content/site1/media/gallery/site1photos/sunflower.jpg
new file mode 100644
index 0000000..516e8d1
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/sunflower.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/sunset.jpg b/example/content/site1/media/gallery/site1photos/sunset.jpg
new file mode 100644
index 0000000..5ecd7f0
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/sunset.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/surfers.jpg b/example/content/site1/media/gallery/site1photos/surfers.jpg
new file mode 100644
index 0000000..c40eecf
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/surfers.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/palms.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/palms.jpg
new file mode 100644
index 0000000..d49d4d8
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/palms.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/passage.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/passage.jpg
new file mode 100644
index 0000000..cd4d746
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/passage.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/pool.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/pool.jpg
new file mode 100644
index 0000000..decd4ca
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/pool.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/sunflower.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/sunflower.jpg
new file mode 100644
index 0000000..37c1fd6
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/sunflower.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/sunset.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/sunset.jpg
new file mode 100644
index 0000000..c26ccd8
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/sunset.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/surfers.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/surfers.jpg
new file mode 100644
index 0000000..a64cca2
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/surfers.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/thumbnails/window.jpg b/example/content/site1/media/gallery/site1photos/thumbnails/window.jpg
new file mode 100644
index 0000000..c527939
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/thumbnails/window.jpg differ
diff --git a/example/content/site1/media/gallery/site1photos/window.jpg b/example/content/site1/media/gallery/site1photos/window.jpg
new file mode 100644
index 0000000..ce7c4a8
Binary files /dev/null and b/example/content/site1/media/gallery/site1photos/window.jpg differ
diff --git a/example/content/site1/shortcode-test.md b/example/content/site1/shortcode-test.md
new file mode 100644
index 0000000..3412e8a
--- /dev/null
+++ b/example/content/site1/shortcode-test.md
@@ -0,0 +1,74 @@
+---
+title: Shortcode Test for Subsite
+date: 2025-01-02
+author: Site1 Admin
+tags: [subsite, testing, shortcodes]
+---
+
+# Shortcode Test
+
+This is a test to verify that shortcodes work correctly in subsites and only show subsite-specific content.
+
+## Tags in this subsite
+
+<!-- .tags -->
+
+## Tags in main site
+
+<!-- .tags site="main" -->
+
+## Authors in this subsite
+
+<!-- .authors -->
+
+
+## Authors in main site
+
+<!-- .authors site="main" -->
+
+## Recent posts in this subsite
+
+<!-- .posts items=2 -->
+
+## Recent posts in main site
+
+<!-- .posts items=2 site="main" -->
+
+
+## Card in this subsite
+
+<!-- .card slug=welcome-to-site1 -->
+
+## Card for author in this subsite
+
+<!-- .card slug=author-site1-admin -->
+
+## Card for author from main site
+
+<!-- .card slug=author-marmite site="main" -->
+
+
+## Card for tag in this subsite
+
+<!-- .card slug=tag-subsite -->
+
+
+## Card for tag from main site
+
+<!-- .card slug=tag-markdown site="main" -->
+
+
+## Gallery in this subsite
+
+<!-- .gallery path=site1photos -->
+
+## Gallery from main site
+
+<!-- .gallery path=summer2025 site="main" -->
+
+## Table of Contents in this subsite
+
+<!-- .toc -->
+
+
+---
\ No newline at end of file
diff --git a/example/content/site1/site.yaml b/example/content/site1/site.yaml
new file mode 100644
index 0000000..11c24ab
--- /dev/null
+++ b/example/content/site1/site.yaml
@@ -0,0 +1,4 @@
+name: A separate site
+theme: theme_template
+enable_search: true
+fragments_fallback: main
\ No newline at end of file
diff --git a/example/shortcodes/authors.html b/example/shortcodes/authors.html
index 3846b88..777f6c2 100644
--- a/example/shortcodes/authors.html
+++ b/example/shortcodes/authors.html
@@ -1,6 +1,6 @@
-{# Display a list of all authors with post counts. Params: ord=desc, items=0 #}
-{% macro authors(ord="desc", items=0) %}
-{% set author_map = group(kind="author", ord=ord, items=items) %}
+{# Display a list of all authors with post counts. Params: ord=desc, items=0, site=current #}
+{% macro authors(ord="desc", items=0, site="") %}
+{% set author_map = group_from_site(kind="author", ord=ord, items=items, site=site) %}
 <ul class="authors-list">
 {% for author_name, posts in author_map %}
 {% set author_slug = author_name | slugify %}
diff --git a/example/shortcodes/card.html b/example/shortcodes/card.html
index 17578b8..b21f16d 100644
--- a/example/shortcodes/card.html
+++ b/example/shortcodes/card.html
@@ -1,5 +1,5 @@
 {# Display a card for content based on slug with optional parameter overrides #}
-{% macro card(slug, image="", title="", text="", content_type="") %}
+{% macro card(slug, image="", title="", text="", content_type="", site="") %}
 {% if slug is starting_with("http://") or slug is starting_with("https://") %}
     {# External URL - skip data lookup and use provided parameters #}
     {% if image %}
@@ -26,7 +26,7 @@
     {% set target_blank = true %}
 {% else %}
     {# Internal content - perform data lookup #}
-    {% set data = get_data_by_slug(slug=slug) %}
+    {% set data = get_data_by_slug_from_site(slug=slug, site=site) %}
     {% if image %}
         {% set final_image = image %}
     {% else %}
diff --git a/example/shortcodes/gallery.html b/example/shortcodes/gallery.html
index 35651e9..e078ed8 100644
--- a/example/shortcodes/gallery.html
+++ b/example/shortcodes/gallery.html
@@ -1,6 +1,6 @@
 {# Display a gallery of images #}
-{% macro gallery(path, ord="", width="100%", height="100%", name="", cover="") %}
-{% set gallery_data = get_gallery(path=path) %}
+{% macro gallery(path, ord="", width="100%", height="100%", name="", cover="", site="") %}
+{% set gallery_data = get_gallery_from_site(path=path, site=site) %}
 
 {% if gallery_data %}
     
@@ -30,7 +30,7 @@ <h3 class="gallery-title">{{ gallery_name }}</h3>
         {# Main image panel #}
         <div class="gallery-main-panel" style="position: relative; width: {{ width }}; height: {{ height }}; margin: 0 auto; overflow: hidden; background: #f0f0f0; display: flex; align-items: center; justify-content: center;">
             <img id="gallery-{{ path }}-main-image" 
-                 src="{{ url_for(path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ cover_image) }}" 
+                 src="{{ url_for_from_site(site=site, path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ cover_image) }}" 
                  alt="{{ gallery_name }}"
                  style="max-width: 100%; max-height: 100%; object-fit: contain; cursor: pointer;"
                  onclick="zoomImage('gallery-{{ path }}')"
@@ -47,8 +47,8 @@ <h3 class="gallery-title">{{ gallery_name }}</h3>
             <div class="gallery-thumbnail-scroll" id="gallery-{{ path }}-scroll" style="overflow-x: hidden; white-space: nowrap; scroll-behavior: smooth; margin: 0 40px;">
                 <div class="gallery-thumbnail-wrapper" style="display: inline-flex; gap: 5px;">
                     {% for item in sorted_files %}
-                    <img src="{{ url_for(path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ item.thumb) }}" 
-                         data-full="{{ url_for(path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ item.image) }}"
+                    <img src="{{ url_for_from_site(site=site, path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ item.thumb) }}" 
+                         data-full="{{ url_for_from_site(site=site, path=site_data.site.media_path ~ '/' ~ site_data.site.gallery_path ~ '/' ~ path ~ '/' ~ item.image) }}"
                          data-description="{{ item.description | default(value='') }}"
                          alt="{{ item.image }}"
                          style="width: 50px; height: 50px; object-fit: cover; cursor: pointer; border: 2px solid transparent;"
diff --git a/example/shortcodes/posts.html b/example/shortcodes/posts.html
index 9e05307..dbf2cee 100644
--- a/example/shortcodes/posts.html
+++ b/example/shortcodes/posts.html
@@ -1,6 +1,6 @@
-{# Display a list of recent posts. Params: ord=desc, items=10 #}
-{% macro posts(ord="desc", items=10) %}
-{% set post_list = get_posts(ord=ord, items=items) %}
+{# Display a list of recent posts. Params: ord=desc, items=10, site=current #}
+{% macro posts(ord="desc", items=10, site="") %}
+{% set post_list = get_posts_from_site(ord=ord, items=items, site=site) %}
 <ul class="posts-list">
 {% for post in post_list %}
 <li><a href="{{ url_for(path=post.slug ~ '.html') }}">{{ post.title }}</a> - {{ post.date | date(format="%Y-%m-%d") }}</li>
diff --git a/example/shortcodes/tags.html b/example/shortcodes/tags.html
index be449bd..8764a40 100644
--- a/example/shortcodes/tags.html
+++ b/example/shortcodes/tags.html
@@ -1,6 +1,6 @@
-{# Display a list of all tags with post counts. Params: ord=desc, items=0 #}
-{% macro tags(ord="desc", items=0) %}
-{% set tag_map = group(kind="tag", ord=ord, items=items) %}
+{# Display a list of all tags with post counts. Params: ord=desc, items=0, site=current #}
+{% macro tags(ord="desc", items=0, site="") %}
+{% set tag_map = group_from_site(kind="tag", ord=ord, items=items, site=site) %}
 <ul class="tags-list">
 {% for tag_name, posts in tag_map %}
 {% set tag_slug = tag_name | slugify %}
diff --git a/src/config.rs b/src/config.rs
index d3e4d4f..476447d 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,7 +1,7 @@
 use log::{error, info};
 use serde::{Deserialize, Serialize};
 use serde_yaml::Value;
-use std::{collections::HashMap, path::Path, process, sync::Arc};
+use std::{collections::HashMap, fs, path::Path, process, sync::Arc};
 
 use crate::cli::Cli;
 
@@ -268,6 +268,9 @@ pub struct Marmite {
 
     #[serde(default = "default_gallery_thumb_size")]
     pub gallery_thumb_size: u32,
+
+    #[serde(default)]
+    pub fragments_fallback: Option<String>,
 }
 
 fn default_true() -> bool {
@@ -419,6 +422,88 @@ impl Marmite {
             self.publish_urls_json = publish_urls_json;
         }
     }
+
+    /// Create a fully configured subsite config by merging with this parent config
+    pub fn with_subsite_config(
+        &self,
+        subsite_config_path: &Path,
+        subsite_name: &str,
+        subsite_path: &Path,
+    ) -> Self {
+        // Read and parse subsite configuration
+        let subsite_config_str = match fs::read_to_string(subsite_config_path) {
+            Ok(content) => content,
+            Err(e) => {
+                error!(
+                    "Failed to read subsite config {}: {e}",
+                    subsite_config_path.display()
+                );
+                return self.clone();
+            }
+        };
+
+        // Read subsite config from file and merge with parent config (file takes precedence over parent config)
+        let mut subsite_config = self.merged_from_subsite_config_file(&subsite_config_str);
+
+        // Set the site_path to include the subsite name
+        if self.site_path.is_empty() {
+            subsite_config.site_path = subsite_name.to_string();
+        } else {
+            subsite_config.site_path = format!("{}/{}", self.site_path, subsite_name);
+        }
+
+        // Update URL to include the subsite path
+        if !subsite_config.url.is_empty() && !subsite_config.url.ends_with('/') {
+            subsite_config.url.push('/');
+        }
+        subsite_config.url.push_str(&subsite_config.site_path);
+
+        // Set content_path to the actual subsite directory
+        subsite_config.content_path = subsite_path.to_string_lossy().to_string();
+
+        subsite_config
+    }
+
+    pub fn merged_from_subsite_config_file(&self, subsite_config_str: &str) -> Self {
+        // Try to parse once into a generic Value
+        let parsed_value: Value = match serde_yaml::from_str(subsite_config_str) {
+            Ok(val) => val,
+            Err(e) => {
+                error!("Failed to parse subsite config: {e}");
+                return self.clone();
+            }
+        };
+        let mut merged_yaml = parsed_value.clone();
+
+        let subsite_keys = parsed_value
+            .as_mapping()
+            .map(|m| {
+                m.keys()
+                    .filter_map(|k| k.as_str().map(std::string::ToString::to_string))
+                    .collect::<std::collections::HashSet<String>>()
+            })
+            .unwrap_or_default();
+
+        let parent_yaml = serde_yaml::to_value(self).unwrap();
+
+        if let (Some(merged_obj), Some(parent_obj)) =
+            (merged_yaml.as_mapping_mut(), parent_yaml.as_mapping())
+        {
+            for (key, value) in parent_obj {
+                if !subsite_keys.contains(key.as_str().unwrap_or_default()) {
+                    merged_obj.insert(key.clone(), value.clone());
+                }
+            }
+        }
+
+        match serde_yaml::from_value(merged_yaml) {
+            Ok(merged) => merged,
+            Err(e) => {
+                error!("Failed to deserialize merged config: {e}");
+                self.clone()
+            }
+        }
+    }
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
diff --git a/src/content.rs b/src/content.rs
index 16ffbb8..95f16d1 100644
--- a/src/content.rs
+++ b/src/content.rs
@@ -588,7 +588,8 @@ pub fn get_authors(frontmatter: &Frontmatter, default_author: Option<String>) ->
             }
         }
     }
-    authors
+    // Ensure each author is slugified
+    authors.iter().map(|a| slugify(a)).collect()
 }
 
 /// Tries to get `date` from the front-matter metadata, else from filename
diff --git a/src/server.rs b/src/server.rs
index 132d964..63ab5f5 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -44,8 +44,29 @@ fn handle_request(
         url => &url[1..], // Remove the leading '/'
     };
 
-    let file_path = output_folder.join(request_path);
-    let error_path = output_folder.join("404.html");
+    let mut file_path = output_folder.join(request_path);
+
+    // If the path is a directory, append index.html
+    if file_path.is_dir() {
+        file_path = file_path.join("index.html");
+    }
+
+    // Check for subsite 404.html if main site 404.html doesn't exist
+    let error_path = if request_path.contains('/') {
+        let parts: Vec<&str> = request_path.split('/').collect();
+        if parts.len() > 1 && !parts[0].is_empty() {
+            let subsite_error = output_folder.join(parts[0]).join("404.html");
+            if subsite_error.exists() {
+                subsite_error
+            } else {
+                output_folder.join("404.html")
+            }
+        } else {
+            output_folder.join("404.html")
+        }
+    } else {
+        output_folder.join("404.html")
+    };
 
     if file_path.is_file() {
         match File::open(&file_path) {
diff --git a/src/site.rs b/src/site.rs
index c2315fc..1dbe3d8 100644
--- a/src/site.rs
+++ b/src/site.rs
@@ -6,7 +6,9 @@ use crate::embedded::{generate_static, Templates, EMBEDDED_TERA};
 use crate::gallery::Gallery;
 use crate::shortcodes::ShortcodeProcessor;
 use crate::tera_functions::{
-    DisplayName, GetDataBySlug, GetGallery, GetPosts, Group, SourceLink, UrlFor,
+    CrossSiteData, DisplayName, GetDataBySlug, GetDataBySlugFromSite, GetGallery,
+    GetGalleryFromSite, GetPosts, GetPostsFromSite, Group, GroupFromSite, SourceLink, UrlFor,
+    UrlForFromSite,
 };
 use crate::{server, tera_filter};
 use chrono::Datelike;
@@ -19,7 +21,7 @@ use rayon::prelude::*;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::vec;
 use std::{fs, process, sync::Arc, sync::Mutex};
 use tera::{Context, Tera};
@@ -56,6 +58,7 @@ pub struct Data {
     pub force_render: bool,
     pub generated_urls: UrlCollection,
     pub galleries: HashMap<String, Gallery>,
+    pub subsites: HashMap<String, Data>,
 }
 
 impl Data {
@@ -68,21 +71,12 @@ impl Data {
             }
         };
 
-        Data {
+        let data = Self {
             site,
-            posts: Vec::new(),
-            pages: Vec::new(),
-            tag: GroupedContent::new(Kind::Tag),
-            archive: GroupedContent::new(Kind::Archive),
-            author: GroupedContent::new(Kind::Author),
-            stream: GroupedContent::new(Kind::Stream),
-            series: GroupedContent::new(Kind::Series),
-            latest_timestamp: None,
             config_path: config_path.to_string_lossy().to_string(),
-            force_render: false,
-            generated_urls: UrlCollection::default(),
-            galleries: HashMap::new(),
-        }
+            ..Default::default()
+        };
+        data
     }
 
     pub fn from_file(config_path: &Path) -> Self {
@@ -428,6 +422,47 @@ impl Data {
             self.generated_urls.add_url("file_mappings", destination);
         }
     }
+
+    /// Create a new Data instance for a subsite
+    pub fn new_for_subsite(
+        parent_config: &Marmite,
+        subsite_config_path: &Path,
+        subsite_name: &str,
+        subsite_path: &Path,
+    ) -> Self {
+        // Create a default Data instance and set the subsite config
+        let data = Self {
+            site: parent_config.with_subsite_config(
+                subsite_config_path,
+                subsite_name,
+                subsite_path,
+            ),
+            config_path: subsite_config_path.to_string_lossy().to_string(),
+            ..Default::default()
+        };
+        data
+    }
+}
+
+impl Default for Data {
+    fn default() -> Self {
+        Self {
+            site: Marmite::default(),
+            posts: Vec::new(),
+            pages: Vec::new(),
+            tag: GroupedContent::new(Kind::Tag),
+            archive: GroupedContent::new(Kind::Archive),
+            author: GroupedContent::new(Kind::Author),
+            stream: GroupedContent::new(Kind::Stream),
+            series: GroupedContent::new(Kind::Series),
+            latest_timestamp: None,
+            config_path: String::new(),
+            force_render: false,
+            generated_urls: UrlCollection::default(),
+            galleries: HashMap::new(),
+            subsites: HashMap::new(),
+        }
+    }
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -509,6 +544,15 @@ pub fn generate(
                 process::exit(1);
             }
 
+            // Process subsites
+            process_subsites(
+                &content_folder,
+                &moved_output_folder,
+                &moved_input_folder,
+                &mut site_data,
+                latest_build_info.as_ref(),
+            );
+
             [
                 "render_templates",
                 "handle_static_artifacts",
@@ -529,6 +573,7 @@ pub fn generate(
                         &fragments,
                         latest_build_info.as_ref(),
                         shortcode_processor.as_ref(),
+                        None, // No parent data for main site
                     ) {
                         error!("Failed to render templates: {e:?}");
                         process::exit(1);
@@ -644,6 +689,49 @@ fn collect_content_fragments(content_dir: &Path) -> HashMap<String, String> {
     markdown_fragments
 }
 
+/// Collect markdown fragments with optional fallback support for subsites
+/// If `fragments_fallback` is set and a fragment is not found locally, look in the fallback site
+fn collect_content_fragments_with_fallback(
+    content_dir: &Path,
+    fragments_fallback: Option<&String>,
+    parent_content_dir: &Path,
+) -> HashMap<String, String> {
+    let fragment_names = ["markdown_header", "markdown_footer", "references"];
+    let mut markdown_fragments = HashMap::new();
+
+    for fragment in fragment_names {
+        let fragment_path = content_dir.join(format!("_{fragment}.md"));
+        let fragment_content = if fragment_path.exists() {
+            // Fragment exists locally, use it
+            fs::read_to_string(fragment_path).unwrap()
+        } else if let Some(fallback_site) = fragments_fallback {
+            // Fragment doesn't exist locally, check fallback site
+            let fallback_path = if fallback_site == "main" {
+                // Fallback to main site (parent content directory)
+                parent_content_dir.join(format!("_{fragment}.md"))
+            } else {
+                // Fallback to another subsite
+                parent_content_dir
+                    .join(fallback_site)
+                    .join(format!("_{fragment}.md"))
+            };
+
+            if fallback_path.exists() {
+                fs::read_to_string(fallback_path).unwrap()
+            } else {
+                String::new()
+            }
+        } else {
+            // No fallback configured, use empty string
+            String::new()
+        };
+
+        markdown_fragments.insert(fragment.to_string(), fragment_content);
+    }
+
+    markdown_fragments
+}
+
 /// Collect global fragments of markdown, process them and insert into the global context
 /// these are dynamic parts of text that will be processed by Tera
 fn collect_global_fragments(
@@ -689,7 +777,7 @@ fn collect_global_fragments(
 }
 
 #[allow(clippy::used_underscore_items)]
-fn collect_back_links(site_data: &mut std::sync::MutexGuard<'_, Data>) {
+fn collect_back_links(site_data: &mut Data) {
     let other_contents = site_data
         .posts
         .clone()
@@ -721,7 +809,7 @@ fn _collect_back_links(contents: &mut [Content], other_contents: &[Content]) {
 }
 
 #[allow(clippy::cast_possible_wrap)]
-fn set_next_and_previous_links(site_data: &mut std::sync::MutexGuard<'_, Data>) {
+fn set_next_and_previous_links(site_data: &mut Data) {
     // First, handle series navigation (takes precedence over stream navigation)
     let mut series_posts: HashMap<String, Vec<Content>> = HashMap::new();
     for post in &site_data.posts {
@@ -806,12 +894,32 @@ fn collect_content(
     site_data: &mut Data,
     fragments: &HashMap<String, String>,
 ) {
+    // First, identify all subsite directories (those containing site.yaml)
+    // But exclude the current directory if it contains site.yaml (we're already processing it)
+    let subsite_dirs: Vec<PathBuf> = WalkDir::new(content_dir)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| {
+            e.path().is_dir() && e.path() != content_dir && e.path().join("site.yaml").exists()
+        })
+        .map(|e| e.path().to_path_buf())
+        .collect();
+
     let contents = WalkDir::new(content_dir)
         .into_iter()
         .filter_map(Result::ok)
         .collect::<Vec<_>>()
         .into_par_iter()
         .filter(|e| {
+            // Skip files that are inside subsite directories
+            let is_in_subsite = subsite_dirs
+                .iter()
+                .any(|subsite_dir| e.path().starts_with(subsite_dir) && e.path() != subsite_dir);
+
+            if is_in_subsite {
+                return false;
+            }
+
             let file_name = e
                 .path()
                 .file_name()
@@ -883,6 +991,7 @@ fn initialize_tera(input_folder: &Path, site_data: &Data) -> (Tera, Option<Short
         "url_for",
         UrlFor {
             base_url: site_data.site.url.to_string(),
+            site_path: site_data.site.site_path.to_string(),
         },
     );
     tera.register_function(
@@ -1015,6 +1124,7 @@ fn render_templates(
     fragments: &HashMap<String, String>,
     latest_build_info: Option<&BuildInfo>,
     shortcode_processor: Option<&ShortcodeProcessor>,
+    parent_data: Option<&Data>,
 ) -> Result<(), String> {
     // Build the context of variables that are global on every template
     let mut global_context = Context::new();
@@ -1025,19 +1135,79 @@ fn render_templates(
     global_context.insert("site", &site_data.site);
     global_context.insert("menu", &site_data.site.menu);
     global_context.insert("language", &site_data.site.language);
+
+    // Always register cross-site functions
+    let mut tera_clone = tera.clone();
+
+    let cross_site_data = if let Some(parent) = parent_data {
+        // For subsites: parent is the main site data
+        global_context.insert("main_site_data", parent);
+        global_context.insert("all_subsites", &parent.subsites);
+
+        CrossSiteData {
+            current_site: site_data.clone(),
+            main_site: Some(parent.clone()),
+            all_subsites: parent.subsites.clone(),
+        }
+    } else {
+        // For main site: it is both current and main site
+        global_context.insert("main_site_data", &site_data);
+        global_context.insert("all_subsites", &site_data.subsites);
+
+        CrossSiteData {
+            current_site: site_data.clone(),
+            main_site: Some(site_data.clone()),
+            all_subsites: site_data.subsites.clone(),
+        }
+    };
+
+    // Register cross-site aware functions
+    tera_clone.register_function(
+        "group_from_site",
+        GroupFromSite {
+            cross_site_data: cross_site_data.clone(),
+        },
+    );
+    tera_clone.register_function(
+        "get_posts_from_site",
+        GetPostsFromSite {
+            cross_site_data: cross_site_data.clone(),
+        },
+    );
+    tera_clone.register_function(
+        "get_data_by_slug_from_site",
+        GetDataBySlugFromSite {
+            cross_site_data: cross_site_data.clone(),
+        },
+    );
+    tera_clone.register_function(
+        "get_gallery_from_site",
+        GetGalleryFromSite {
+            cross_site_data: cross_site_data.clone(),
+        },
+    );
+    tera_clone.register_function("url_for_from_site", UrlForFromSite { cross_site_data });
+
+    let tera_to_use = &tera_clone;
+
     debug!("Global Context site: {:?}", &site_data.site);
     debug!("Site data galleries count: {}", site_data.galleries.len());
-    collect_global_fragments(content_dir, &mut global_context, tera, &site_data.site);
+    collect_global_fragments(
+        content_dir,
+        &mut global_context,
+        tera_to_use,
+        &site_data.site,
+    );
 
-    handle_stream_pages(&site_data, &global_context, tera, output_dir)?;
-    handle_series_pages(&site_data, &global_context, tera, output_dir)?;
+    handle_stream_pages(&site_data, &global_context, tera_to_use, output_dir)?;
+    handle_series_pages(&site_data, &global_context, tera_to_use, output_dir)?;
     // If site_data.stream.map does not contain the index stream
     // we will render empty index.html from list.html template
     if !site_data.stream.map.contains_key("index") {
-        handle_default_empty_site(&global_context, tera, output_dir)?;
+        handle_default_empty_site(&global_context, tera_to_use, output_dir)?;
     }
 
-    handle_group_pages(&global_context, &site_data, tera, output_dir)?;
+    handle_group_pages(&global_context, &site_data, tera_to_use, output_dir)?;
 
     // Pages are treated as a list of content, no stream separation is needed
     // pages are usually just static pages that user will link in the menu.
@@ -1046,13 +1216,13 @@ fn render_templates(
         &site_data.site.pages_title,
         &site_data.pages,
         &site_data,
-        tera,
+        tera_to_use,
         output_dir,
         "pages",
     )?;
 
     // Check and guarantees that page 404 was generated even if _404.md is removed
-    handle_404(content_dir, &global_context, tera, output_dir)?;
+    handle_404(content_dir, &global_context, tera_to_use, output_dir)?;
 
     // Render individual content-slug.html from content.html template
     // content is rendered as last step so it gives the user the ability to
@@ -1060,7 +1230,7 @@ fn render_templates(
     handle_content_pages(
         &site_data,
         &global_context,
-        tera,
+        tera_to_use,
         output_dir,
         content_dir,
         input_folder,
@@ -1708,11 +1878,7 @@ fn copy_markdown_sources(site_data: &Data, content_folder: &Path, output_path: &
         });
 }
 
-fn write_build_info(
-    output_path: &Path,
-    site_data: &std::sync::MutexGuard<'_, Data>,
-    end_time: f64,
-) {
+fn write_build_info(output_path: &Path, site_data: &Data, end_time: f64) {
     let build_info = BuildInfo {
         marmite_version: env!("CARGO_PKG_VERSION").to_string(),
         posts: site_data.posts.len(),
@@ -1742,6 +1908,7 @@ fn generate_sitemap(site_data: &Data, tera: &Tera, output_path: &Path) {
     // Create UrlFor function instance
     let url_for = UrlFor {
         base_url: site_data.site.url.clone(),
+        site_path: site_data.site.site_path.clone(),
     };
 
     // Helper to generate URL using url_for
@@ -1800,6 +1967,7 @@ fn create_urls_json(site_data: &Data) -> serde_json::Value {
     // Create UrlFor function instance
     let url_for = UrlFor {
         base_url: site_data.site.url.clone(),
+        site_path: site_data.site.site_path.clone(),
     };
 
     // Determine if we should use absolute URLs
@@ -2782,8 +2950,17 @@ pub fn show_urls(
     // Collect all URLs including pagination, feeds, and file mappings
     site_data.collect_all_urls();
 
-    // Generate JSON using the shared function
-    let json = create_urls_json(&site_data);
+    // Generate JSON for main site
+    let mut json = create_urls_json(&site_data);
+
+    // Process subsites and add their URLs
+    let subsites_urls = collect_subsites_urls(&content_folder, input_folder.as_path(), &site_data);
+    if !subsites_urls.is_empty() {
+        json.as_object_mut().unwrap().insert(
+            "subsites".to_string(),
+            serde_json::Value::Object(subsites_urls),
+        );
+    }
 
     // Output JSON
     match serde_json::to_string_pretty(&json) {
@@ -2792,6 +2969,351 @@ pub fn show_urls(
     }
 }
 
+/// Collect URLs from all subsites for the --show-urls command
+fn collect_subsites_urls(
+    content_folder: &Path,
+    input_folder: &Path,
+    parent_site_data: &Data,
+) -> serde_json::Map<String, serde_json::Value> {
+    let mut subsites_urls = serde_json::Map::new();
+
+    // Look for directories in content folder that contain a site.yaml file
+    let entries = match fs::read_dir(content_folder) {
+        Ok(entries) => entries,
+        Err(e) => {
+            error!("Failed to read content directory for subsites: {e}");
+            return subsites_urls;
+        }
+    };
+
+    for entry in entries.flatten() {
+        let entry_path = entry.path();
+        if entry_path.is_dir() {
+            let site_yaml_path = entry_path.join("site.yaml");
+            if site_yaml_path.exists() {
+                let subsite_name = entry_path
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .unwrap_or("unknown")
+                    .to_string();
+
+                // Process this subsite for URL collection
+                let single_subsite_urls = collect_single_subsite_urls(
+                    &subsite_name,
+                    &entry_path,
+                    &site_yaml_path,
+                    input_folder,
+                    parent_site_data,
+                );
+                subsites_urls.insert(subsite_name, single_subsite_urls);
+            }
+        }
+    }
+
+    subsites_urls
+}
+
+/// Collect URLs from a single subsite
+fn collect_single_subsite_urls(
+    subsite_name: &str,
+    subsite_path: &Path,
+    site_yaml_path: &Path,
+    input_folder: &Path,
+    parent_site_data: &Data,
+) -> serde_json::Value {
+    // Create subsite data with the configured site config
+    let mut subsite_data = Data::new_for_subsite(
+        &parent_site_data.site,
+        site_yaml_path,
+        subsite_name,
+        subsite_path,
+    );
+
+    // Collect fragments for the subsite with fallback support
+    let parent_content_dir = input_folder.join(&parent_site_data.site.content_path);
+    let fragments = collect_content_fragments_with_fallback(
+        subsite_path,
+        subsite_data.site.fragments_fallback.as_ref(),
+        &parent_content_dir,
+    );
+
+    // Collect content for the subsite
+    collect_content(&subsite_path.to_path_buf(), &mut subsite_data, &fragments);
+    subsite_data.sort_all();
+
+    // Collect all URLs including pagination, feeds, and file mappings
+    subsite_data.collect_all_urls();
+
+    // Generate JSON using the shared function
+    create_urls_json(&subsite_data)
+}
+
+/// Process subsites found in the content directory
+fn process_subsites(
+    content_folder: &Path,
+    output_folder: &Path,
+    input_folder: &Path,
+    parent_site_data: &mut Data,
+    latest_build_info: Option<&BuildInfo>,
+) {
+    // Look for directories in content folder that contain a site.yaml file
+    let entries = match fs::read_dir(content_folder) {
+        Ok(entries) => entries,
+        Err(e) => {
+            error!("Failed to read content directory for subsites: {e}");
+            return;
+        }
+    };
+
+    for entry in entries.filter_map(Result::ok) {
+        let path = entry.path();
+        if path.is_dir() {
+            let site_yaml_path = path.join("site.yaml");
+            if site_yaml_path.exists() {
+                let Some(subsite_name) = path.file_name().and_then(|n| n.to_str()) else {
+                    continue;
+                };
+
+                info!("Processing subsite: {subsite_name}");
+
+                // Process the subsite and store the data
+                if let Some(subsite_data) = process_single_subsite(
+                    subsite_name,
+                    &path,
+                    &site_yaml_path,
+                    output_folder,
+                    input_folder,
+                    parent_site_data,
+                    latest_build_info,
+                ) {
+                    parent_site_data
+                        .subsites
+                        .insert(subsite_name.to_string(), subsite_data);
+                }
+            }
+        }
+    }
+}
+
+/// Process a single subsite
+#[allow(clippy::too_many_arguments)]
+fn process_single_subsite(
+    subsite_name: &str,
+    subsite_path: &Path,
+    site_yaml_path: &Path,
+    output_folder: &Path,
+    input_folder: &Path,
+    parent_site_data: &Data,
+    latest_build_info: Option<&BuildInfo>,
+) -> Option<Data> {
+    // Create subsite data with the configured site config
+    let mut subsite_data = Data::new_for_subsite(
+        &parent_site_data.site,
+        site_yaml_path,
+        subsite_name,
+        subsite_path,
+    );
+
+    // Collect fragments for the subsite with fallback support
+    let parent_content_dir = input_folder.join(&parent_site_data.site.content_path);
+    let fragments = collect_content_fragments_with_fallback(
+        subsite_path,
+        subsite_data.site.fragments_fallback.as_ref(),
+        &parent_content_dir,
+    );
+
+    // Collect content for the subsite
+    collect_content(&subsite_path.to_path_buf(), &mut subsite_data, &fragments);
+
+    // Process galleries for the subsite
+    let media_path = subsite_path.join(&subsite_data.site.media_path);
+    if media_path.exists() {
+        subsite_data.galleries = crate::gallery::process_galleries(
+            &media_path,
+            &subsite_data.site.gallery_path,
+            subsite_data.site.gallery_create_thumbnails,
+            subsite_data.site.gallery_thumb_size,
+        );
+    }
+
+    // Sort and process the subsite data
+    subsite_data.sort_all();
+    detect_slug_collision(&subsite_data);
+    collect_back_links(&mut subsite_data);
+    set_next_and_previous_links(&mut subsite_data);
+    subsite_data.collect_all_urls();
+
+    // Create output directory for the subsite
+    let subsite_output_path = output_folder.join(&subsite_data.site.site_path);
+    if let Err(e) = fs::create_dir_all(&subsite_output_path) {
+        error!("Unable to create subsite output directory: {e:?}");
+        return None;
+    }
+
+    // Initialize Tera for the subsite with its own theme
+    let (tera, shortcode_processor) = initialize_tera_for_subsite(
+        input_folder,
+        &subsite_data,
+        parent_site_data.site.theme.as_ref(),
+    );
+
+    // Render templates for the subsite
+    if let Err(e) = render_templates(
+        subsite_path,
+        &subsite_data,
+        &tera,
+        &subsite_output_path,
+        input_folder,
+        &fragments,
+        latest_build_info,
+        shortcode_processor.as_ref(),
+        Some(parent_site_data), // Pass parent data for cross-site references
+    ) {
+        error!("Failed to render subsite templates: {e:?}");
+        return None;
+    }
+
+    // Handle static artifacts for the subsite
+    handle_static_artifacts_for_subsite(
+        input_folder,
+        &subsite_data,
+        output_folder,
+        subsite_path,
+        subsite_name,
+    );
+
+    // Generate search index for the subsite
+    if subsite_data.site.enable_search {
+        generate_search_index_for_subsite(&subsite_data, output_folder, subsite_name);
+    }
+
+    // Copy markdown sources if enabled
+    if subsite_data.site.publish_md {
+        copy_markdown_sources_for_subsite(&subsite_data, &subsite_output_path);
+    }
+
+    // Generate feeds for the subsite
+    if subsite_data.site.json_feed {
+        if let Err(e) = crate::feed::generate_json(
+            &subsite_data.posts,
+            &subsite_output_path,
+            "feed",
+            &subsite_data.site,
+        ) {
+            error!("Failed to generate JSON feed for subsite: {e}");
+        }
+    }
+
+    if let Err(e) = crate::feed::generate_rss(
+        &subsite_data.posts,
+        &subsite_output_path,
+        "feed",
+        &subsite_data.site,
+    ) {
+        error!("Failed to generate RSS feed for subsite: {e}");
+    }
+
+    // Generate sitemap and other files
+    generate_sitemap(&subsite_data, &tera, &subsite_output_path);
+
+    if subsite_data.site.publish_urls_json {
+        generate_urls_json(&subsite_data, &subsite_output_path);
+    }
+
+    info!("Subsite '{subsite_name}' generated successfully");
+    Some(subsite_data)
+}
+
+/// Initialize Tera for a subsite with its own theme
+fn initialize_tera_for_subsite(
+    input_folder: &Path,
+    site_data: &Data,
+    _parent_theme: Option<&String>,
+) -> (Tera, Option<ShortcodeProcessor>) {
+    // Initialize Tera with the appropriate theme
+    // This reuses the existing initialize_tera function
+    initialize_tera(input_folder, site_data)
+}
+
+/// Handle static artifacts for a subsite
+fn handle_static_artifacts_for_subsite(
+    input_folder: &Path,
+    site_data: &Data,
+    output_folder: &Path,
+    content_folder: &Path,
+    _subsite_name: &str,
+) {
+    // Similar to handle_static_artifacts but with subsite paths
+    let site_output_path = output_folder.join(&site_data.site.site_path);
+
+    // Copy media files from subsite
+    let media_src = content_folder.join(&site_data.site.media_path);
+    if media_src.exists() {
+        if let Err(e) = dircopy(
+            &media_src,
+            &site_output_path,
+            &CopyOptions::new().overwrite(true),
+        ) {
+            error!("Failed to copy subsite media: {e}");
+        }
+    }
+
+    // Copy static files if they exist for the subsite
+    let static_src = input_folder.join("static");
+    if static_src.exists() {
+        if let Err(e) = dircopy(
+            &static_src,
+            &site_output_path,
+            &CopyOptions::new().overwrite(true),
+        ) {
+            error!("Failed to copy subsite static files: {e}");
+        }
+    }
+
+    // Handle theme-specific static files for the subsite
+    if let Some(theme) = &site_data.site.theme {
+        let theme_static_src = input_folder.join(theme).join("static");
+        if theme_static_src.exists() {
+            let static_dst = site_output_path.join("static");
+            // Create the static directory first
+            if let Err(e) = std::fs::create_dir_all(&static_dst) {
+                error!("Failed to create static directory: {e}");
+            }
+            // Copy only the contents of the theme static directory
+            let mut options = CopyOptions::new();
+            options.overwrite = true;
+            options.content_only = true;
+            if let Err(e) = dircopy(&theme_static_src, &static_dst, &options) {
+                error!("Failed to copy subsite theme static files: {e}");
+            }
+        }
+    }
+}
+
+/// Generate search index for a subsite
+fn generate_search_index_for_subsite(site_data: &Data, output_folder: &Path, _subsite_name: &str) {
+    let subsite_output_path = Arc::new(output_folder.join(&site_data.site.site_path));
+
+    // Generate search index specific to this subsite
+    generate_search_index(site_data, &subsite_output_path);
+}
+
+/// Copy markdown sources for a subsite
+fn copy_markdown_sources_for_subsite(site_data: &Data, output_path: &Path) {
+    // Copy markdown files for the subsite
+    for content in site_data.posts.iter().chain(site_data.pages.iter()) {
+        if let Some(source_path) = &content.source_path {
+            let source_file = Path::new(source_path);
+            if let Some(file_name) = source_file.file_name() {
+                let dest_path = output_path.join(file_name);
+                if let Err(e) = fs::copy(source_file, dest_path) {
+                    error!("Failed to copy markdown source: {e}");
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/tera_functions.rs b/src/tera_functions.rs
index 4155e71..f2bf35d 100644
--- a/src/tera_functions.rs
+++ b/src/tera_functions.rs
@@ -1,4 +1,5 @@
 use indexmap::IndexMap;
+use log::error;
 use serde::Serialize;
 use std::collections::HashMap;
 use tera::{to_value, Function, Result as TeraResult, Value};
@@ -19,6 +20,7 @@ pub struct SlugData {
 #[derive(Default)]
 pub struct UrlFor {
     pub base_url: String,
+    pub site_path: String,
 }
 
 impl Function for UrlFor {
@@ -67,6 +69,9 @@ impl Function for UrlFor {
         } else if !base_path.is_empty() {
             // Relative URL with base path from base_url
             format!("{base_path}{path}")
+        } else if !self.site_path.is_empty() {
+            // Add site_path prefix for subsites when not using absolute URLs
+            format!("/{}{}", self.site_path.trim_matches('/'), path)
         } else {
             // Just the path if no base_url or base_path
             path
@@ -340,6 +345,7 @@ impl Function for GetDataBySlug {
                     content_type: "series".to_string(),
                 }
             } else {
+                error!("Series not found: {series_name}");
                 return Err(tera::Error::msg(format!("Series not found: {series_name}")));
             }
         } else if slug.starts_with("stream-") {
@@ -379,6 +385,7 @@ impl Function for GetDataBySlug {
                     content_type: "stream".to_string(),
                 }
             } else {
+                error!("Stream not found: {stream_name}");
                 return Err(tera::Error::msg(format!("Stream not found: {stream_name}")));
             }
         } else if slug.starts_with("tag-") {
@@ -399,6 +406,7 @@ impl Function for GetDataBySlug {
                     content_type: "tag".to_string(),
                 }
             } else {
+                error!("Tag not found: {tag_name}");
                 return Err(tera::Error::msg(format!("Tag not found: {tag_name}")));
             }
         } else if slug.starts_with("author-") {
@@ -412,8 +420,8 @@ impl Function for GetDataBySlug {
 
                 let image = author_info
                     .and_then(|a| a.avatar.as_ref())
-                    .unwrap_or(&self.site_data.site.banner_image)
-                    .clone();
+                    .map_or("static/avatar-placeholder.png", |s| s)
+                    .to_string();
 
                 SlugData {
                     image,
@@ -423,6 +431,7 @@ impl Function for GetDataBySlug {
                     content_type: "author".to_string(),
                 }
             } else {
+                error!("Author not found: {author_name}");
                 return Err(tera::Error::msg(format!("Author not found: {author_name}")));
             }
         } else if slug.starts_with("archive-") {
@@ -443,6 +452,7 @@ impl Function for GetDataBySlug {
                     content_type: "archive".to_string(),
                 }
             } else {
+                error!("Archive year not found: {year}");
                 return Err(tera::Error::msg(format!("Archive year not found: {year}")));
             }
         } else {
@@ -506,6 +516,7 @@ impl Function for GetDataBySlug {
                     content_type: "stream".to_string(),
                 }
             } else {
+                error!("Content not found for slug: {slug}");
                 return Err(tera::Error::msg(format!(
                     "Content not found for slug: {slug}"
                 )));
@@ -547,6 +558,180 @@ impl Function for GetGallery {
     }
 }
 
+/// Wrapper for cross-site data access
+#[derive(Clone)]
+pub struct CrossSiteData {
+    pub current_site: Data,
+    pub main_site: Option<Data>,
+    pub all_subsites: HashMap<String, Data>,
+}
+
+/// Cross-site aware version of group function
+pub struct GroupFromSite {
+    pub cross_site_data: CrossSiteData,
+}
+
+impl Function for GroupFromSite {
+    fn call(&self, args: &HashMap<String, Value>) -> TeraResult<Value> {
+        let site = args.get("site").and_then(Value::as_str).unwrap_or("");
+
+        // Determine which site data to use
+        let target_data = if site == "main" {
+            self.cross_site_data
+                .main_site
+                .as_ref()
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else if !site.is_empty() {
+            self.cross_site_data
+                .all_subsites
+                .get(site)
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else {
+            // Default: use current site (empty string means current site)
+            &self.cross_site_data.current_site
+        };
+
+        // Call the original Group function with the target data
+        let group_fn = Group {
+            site_data: target_data.clone(),
+        };
+        group_fn.call(args)
+    }
+}
+
+/// Cross-site aware version of `get_posts` function
+pub struct GetPostsFromSite {
+    pub cross_site_data: CrossSiteData,
+}
+
+impl Function for GetPostsFromSite {
+    fn call(&self, args: &HashMap<String, Value>) -> TeraResult<Value> {
+        let site = args.get("site").and_then(Value::as_str).unwrap_or("");
+
+        // Determine which site data to use
+        let target_data = if site == "main" {
+            self.cross_site_data
+                .main_site
+                .as_ref()
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else if !site.is_empty() {
+            self.cross_site_data
+                .all_subsites
+                .get(site)
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else {
+            // Default: use current site (empty string means current site)
+            &self.cross_site_data.current_site
+        };
+
+        // Call the original GetPosts function with the target data
+        let get_posts_fn = GetPosts {
+            site_data: target_data.clone(),
+        };
+        get_posts_fn.call(args)
+    }
+}
+
+/// Cross-site aware version of `get_data_by_slug` function
+pub struct GetDataBySlugFromSite {
+    pub cross_site_data: CrossSiteData,
+}
+
+impl Function for GetDataBySlugFromSite {
+    fn call(&self, args: &HashMap<String, Value>) -> TeraResult<Value> {
+        let site = args.get("site").and_then(Value::as_str).unwrap_or("");
+
+        // Determine which site data to use
+        let target_data = if site == "main" {
+            self.cross_site_data
+                .main_site
+                .as_ref()
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else if !site.is_empty() {
+            self.cross_site_data
+                .all_subsites
+                .get(site)
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else {
+            // Default: use current site (empty string means current site)
+            &self.cross_site_data.current_site
+        };
+
+        // Call the original GetDataBySlug function with the target data
+        let get_data_fn = GetDataBySlug {
+            site_data: target_data.clone(),
+        };
+        get_data_fn.call(args)
+    }
+}
+
+/// Cross-site aware version of `get_gallery` function
+pub struct GetGalleryFromSite {
+    pub cross_site_data: CrossSiteData,
+}
+
+impl Function for GetGalleryFromSite {
+    fn call(&self, args: &HashMap<String, Value>) -> TeraResult<Value> {
+        let site = args.get("site").and_then(Value::as_str).unwrap_or("");
+
+        // Determine which site data to use
+        let target_data = if site == "main" {
+            self.cross_site_data
+                .main_site
+                .as_ref()
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else if !site.is_empty() {
+            self.cross_site_data
+                .all_subsites
+                .get(site)
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else {
+            // Default: use current site (empty string means current site)
+            &self.cross_site_data.current_site
+        };
+
+        // Call the original GetGallery function with the target data
+        let get_gallery_fn = GetGallery {
+            site_data: target_data.clone(),
+        };
+        get_gallery_fn.call(args)
+    }
+}
+
+/// Cross-site aware version of `url_for` function
+pub struct UrlForFromSite {
+    pub cross_site_data: CrossSiteData,
+}
+
+impl Function for UrlForFromSite {
+    fn call(&self, args: &HashMap<String, Value>) -> TeraResult<Value> {
+        let site = args.get("site").and_then(Value::as_str).unwrap_or("");
+
+        // Determine which site data to use
+        let target_data = if site == "main" {
+            self.cross_site_data
+                .main_site
+                .as_ref()
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else if !site.is_empty() {
+            self.cross_site_data
+                .all_subsites
+                .get(site)
+                .unwrap_or(&self.cross_site_data.current_site)
+        } else {
+            // Default: use current site (empty string means current site)
+            &self.cross_site_data.current_site
+        };
+
+        // Create url_for function with the target site data
+        let url_for_fn = UrlFor {
+            base_url: target_data.site.url.clone(),
+            site_path: target_data.site.site_path.clone(),
+        };
+        url_for_fn.call(args)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -558,6 +743,7 @@ mod tests {
     fn test_url_for_basic_path() {
         let url_for = UrlFor {
             base_url: String::new(),
+            site_path: String::new(),
         };
         let mut args = HashMap::new();
         args.insert("path".to_string(), Value::String("about.html".to_string()));
@@ -570,6 +756,7 @@ mod tests {
     fn test_url_for_absolute_path() {
         let url_for = UrlFor {
             base_url: "https://example.com".to_string(),
+            site_path: String::new(),
         };
         let mut args = HashMap::new();
         args.insert("path".to_string(), Value::String("about.html".to_string()));
@@ -586,6 +773,7 @@ mod tests {
     fn test_url_for_external_url() {
         let url_for = UrlFor {
             base_url: String::new(),
+            site_path: String::new(),
         };
         let mut args = HashMap::new();
         args.insert(
@@ -601,6 +789,7 @@ mod tests {
     fn test_url_for_missing_path() {
         let url_for = UrlFor {
             base_url: String::new(),
+            site_path: String::new(),
         };
         let args = HashMap::new();