Static Site GeneratorA Static Site Generator (SSG) is a tool that takes content, data, and templates, and combines them to generate a complete set of static HTML, CSS, and JavaScript files. Unlike a Content Management System (CMS) like WordPress, which builds pages dynamically on each request, an SSG generates all pages upfront during a 'build' process. The output is a collection of pre-rendered files that can be served directly by any web server.
How it Works:
1. Content: You provide your content, often in simple formats like Markdown, YAML, JSON, or plain text files.
2. Templates: You define the layout and structure of your pages using templates (e.g., HTML files with placeholders for content and data).
3. Data: Optionally, you can provide additional data (e.g., author information, navigation links) in structured formats like JSON or YAML.
4. Generation Process: The SSG takes all these inputs, processes them, and renders static HTML files for each page, applying the specified templates and injecting content and data.
5. Deployment: The generated static files are then uploaded to a web server (e.g., Nginx, Apache, or a CDN).
Key Advantages:
* Performance: Static files are served directly, eliminating database queries and server-side processing, leading to extremely fast load times.
* Security: There's no server-side code, database, or dynamic components to exploit, significantly reducing the attack surface.
* Simplicity: Deployment is often as simple as copying files to a server. Hosting costs can be very low, or even free (e.g., GitHub Pages, Netlify).
* Scalability: Serving static files is highly scalable, as caching is straightforward and content delivery networks (CDNs) can distribute content globally with ease.
* Developer Experience: Developers can use familiar tools, version control (Git), and modern front-end frameworks without dealing with complex backend systems.
Common Use Cases:
* Blogs and personal websites
* Documentation sites
* Marketing and landing pages
* E-commerce sites (in combination with third-party APIs)
* Portfolios
Comparison to CMS:
While a CMS offers dynamic content management and real-time updates, an SSG sacrifices this dynamism for speed, security, and simplicity. Updates to an SSG-powered site typically require a rebuild and redeployment process. However, for many types of websites where content doesn't change by the minute, an SSG is a superior solution.
The Rust example demonstrates a very basic SSG. It reads Markdown files from a `content/` directory, converts them to HTML, and inserts them into a simple HTML template from `templates/page.html`. The final HTML files are then written to an `output/` directory.
Example Code
```rust
// File: src/main.rs
use std::fs;
use std::path::{Path, PathBuf};
// A minimal function to convert markdown to HTML
fn markdown_to_html(markdown_input: &str) -> String {
// We'll use the pulldown-cmark crate for robust Markdown parsing.
// Add `pulldown-cmark = "0.9"` to your Cargo.toml dependencies.
let parser = pulldown_cmark::Parser::new(markdown_input);
let mut html_output = String::new();
pulldown_cmark::html::push_html(&mut html_output, parser);
html_output
}
// A simple function to extract a title from the first H1 tag in Markdown
fn extract_title_from_markdown(markdown_input: &str) -> String {
markdown_input
.lines()
.find(|line| line.starts_with("# "))
.map(|line| line.trim_start_matches("# ").to_string())
.unwrap_or_else(|| "Untitled Page".to_string())
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("Starting static site generation...");
let content_dir = PathBuf::from("content");
let templates_dir = PathBuf::from("templates");
let output_dir = PathBuf::from("output");
// 1. Ensure output directory exists and is empty
if output_dir.exists() {
fs::remove_dir_all(&output_dir)?; // Remove existing content
}
fs::create_dir_all(&output_dir)?;
// 2. Read the main template file
let template_path = templates_dir.join("page.html");
let page_template = fs::read_to_string(&template_path)
.map_err(|e| format!("Failed to read template file {:?}: {}", template_path, e))?;
println!("Template loaded from {:?}", template_path);
// 3. Process content files
println!("Processing content files from {:?}", content_dir);
for entry in fs::read_dir(&content_dir)? {
let entry = entry?;
let path = entry.path();
if path.is_file() && path.extension().map_or(false, |ext| ext == "md") {
let markdown_content = fs::read_to_string(&path)?;
let html_content = markdown_to_html(&markdown_content);
let title = extract_title_from_markdown(&markdown_content);
// Fill the template
let final_html = page_template
.replace("{{title}}", &title)
.replace("{{content}}", &html_content);
// Determine output filename (e.g., post1.md -> post1.html)
let output_filename = path
.file_stem()
.and_then(|s| s.to_str())
.map(|s| format!("{}.html", s))
.unwrap_or_else(|| "index.html".to_string()); // Fallback
let output_path = output_dir.join(output_filename);
fs::write(&output_path, final_html)?;
println!("Generated: {:?} -> {:?}", path, output_path);
}
}
println!("Static site generation complete!");
Ok(())
}
```
```toml
# File: Cargo.toml
[package]
name = "rust_ssg_example"
version = "0.1.0"
edition = "2021"
[dependencies]
pulldown-cmark = "0.9"
```
```html
<!-- File: templates/page.html -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>{{title}} - My Static Site</title>
<style>
body { font-family: sans-serif; margin: 2em; line-height: 1.6; }
header { background: #f4f4f4; padding: 1em; text-align: center; }
main { max-width: 800px; margin: 2em auto; padding: 1em; border: 1px solid #ddd; }
footer { text-align: center; margin-top: 2em; color: #777; }
h1, h2, h3 { color: #333; }
</style>
</head>
<body>
<header>
<h1>My Rust Static Site</h1>
<nav>
<a href="index.html">Home</a> |
<a href="about.html">About</a>
</nav>
</header>
<main>
<h1>{{title}}</h1>
{{content}}
</main>
<footer>
<p>© 2023 My Rust SSG Example</p>
</footer>
</body>
</html>
```
```markdown
<!-- File: content/index.md -->
# Welcome to My Site!
This is the homepage of my static site, generated with Rust!
Here are some features:
* Fast loading times
* Secure by default
* Easy to deploy
Check out the [About Page](about.html).
```
```markdown
<!-- File: content/about.md -->
# About This Project
This simple project demonstrates the core concepts of a Static Site Generator using Rust.
It takes Markdown files, converts them to HTML, and injects them into a pre-defined HTML template.
How to Run:
1. Save the `src/main.rs`, `Cargo.toml`, `templates/page.html`, `content/index.md`, and `content/about.md` files into their respective locations.
2. Navigate to the project root directory in your terminal.
3. Run `cargo run`.
An `output/` directory will be created, containing `index.html` and `about.html`.
```