5 -- AI-powered readability fix (requires Ollama)

ssg -c content -o public -t templates --ai-fix ```

---

Install

[dependencies]
ssg = "0.0.59"

Build from source

git clone https://github.com/sebastienrousseau/static-site-generator.git
cd static-site-generator
make          # check + clippy + test

Requires Rust 1.88.0+. Tested on Linux, macOS, and Windows.

System install (packagers)

make install                      # to /usr/local
make PREFIX=/usr install          # to /usr
make DESTDIR=/tmp/stage install   # staged, for packaging
make uninstall                    # exact inverse of install

Installs the binary, the ssg.1 man page and bash, zsh and fish completions to their FHS locations. The man page and completions are generated from the CLI definition at build time, so man ssg cannot drift from ssg --help; CI asserts that on every push. PowerShell completions are generated too, and installed when PWSHCOMPDIR is set.

---

1 -- Install

cargo install ssg

3 -- Build

ssg -c content -o public -t templates

Build performance

Reproduce: cargo bench --bench bench -- scalability.

---

Build flags

      --incremental        Skip recompile when DepGraph diff is empty (issue #524)
      --isr                Emit an SHA-256-keyed ISR manifest for Edge adapters (issue #549)
      --no-llm-cache       Bypass the deterministic LLM inference cache (issue #528)

Quick Start

```bash

Library Usage

<details> <summary><b>Minimal pipeline</b></summary>

,no_run
fn main() -> Result<(), ssg::error::SsgError> {
    ssg::run()
}

</details>

<details> <summary><b>Custom plugin</b></summary>

,no_run
use ssg::plugin::{Plugin, PluginContext, PluginManager};
use ssg::error::SsgError;
use std::path::Path;

#[derive(Debug)]
struct LogPlugin;

impl Plugin for LogPlugin {
    fn name(&self) -> &str { "logger" }
    fn after_compile(&self, ctx: &PluginContext) -> Result<(), SsgError> {
        println!("Site compiled to {:?}", ctx.site_dir);
        Ok(())
    }
}

fn main() -> Result<(), SsgError> {
    let mut pm = PluginManager::new();
    pm.register(LogPlugin);
    pm.register(ssg::plugins::MinifyPlugin);

    let ctx = PluginContext::new(
        Path::new("content"),
        Path::new("build"),
        Path::new("public"),
        Path::new("templates"),
    );
    pm.run_after_compile(&ctx)?;
    Ok(())
}

</details>

<details> <summary><b>Content schema validation</b></summary>

Create content/content.schema.toml:

[[schemas]]
name = "post"

[[schemas.fields]]
name = "title"
type = "string"
required = true

[[schemas.fields]]
name = "date"
type = "date"
required = true

[[schemas.fields]]
name = "draft"
type = "bool"
default = "false"

Pages with schema = "post" in their frontmatter are validated at compile time. Run ssg --validate for schema-only checks.

</details>

<details> <summary><b>Readability audit</b></summary>

,no_run
use ssg::llm::{LlmPlugin, LlmConfig};
use std::path::Path;

let report = LlmPlugin::audit_all(Path::new("content"), 8.0).unwrap();
println!("{}/{} files pass grade 8.0", report.passing, report.total_files);

// Multilingual: French content uses Kandel-Moles automatically
// when frontmatter contains `language: fr`

</details>

<details> <summary><b>OG image generation</b></summary>

,no_run
use ssg::og_image::generate_og_svg;

let svg = generate_og_svg("My Page Title", "My Site", "#1a1a2e", "#ffffff");
std::fs::write("og-card.svg", svg).unwrap();
// 1200x630 SVG social card ready for og:image

</details>

<details> <summary><b>Vector search index (issue #545)</b></summary>

,no_run
use ssg_search::artifacts::{Artifacts, InputDoc};
use ssg_search::VectorEngine;

// Build side: turn a doc corpus into the 4-file artifact blob.
let docs = vec![
    InputDoc {
        url: "/post-1".into(),
        title: "Rust WebAssembly".into(),
        body: "rust compiles to wasm".into(),
        excerpt: "rust wasm".into(),
    },
    InputDoc {
        url: "/post-2".into(),
        title: "Sourdough".into(),
        body: "starter flour water salt".into(),
        excerpt: "bread".into(),
    },
];
let arts = Artifacts::from_docs(&docs);
std::fs::write("site/search/embeddings.bin", &arts.embeddings).unwrap();
std::fs::write("site/search/model.bin", &arts.model).unwrap();
std::fs::write("site/search/tokenizer.bin", &arts.tokenizer).unwrap();

// Runtime (native or WASM): load and query.
let engine = VectorEngine::new(
    &arts.model, &arts.tokenizer, &arts.embeddings, arts.count(),
).unwrap();
let top = engine.search("rust webassembly", 3);
println!("{:?}", top);

</details>

<details> <summary><b>Edge RPC method (issue #548)</b></summary>

,ignore
use ssg_rpc::ssg_rpc;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, JsonSchema)]
struct EchoIn { msg: String }

#[derive(Serialize, JsonSchema)]
struct EchoOut { msg: String }

#[ssg_rpc]
fn echo(input: EchoIn) -> Result<EchoOut, ssg_rpc::DispatchError> {
    Ok(EchoOut { msg: input.msg })
}

// The build emits `site/rpc.d.ts` automatically; clients call:
//   const r = await ssgRpc("echo", { msg: "hi" });

</details>

<details> <summary><b>Audit a built site (issue #551)</b></summary>

```bash ssg audit site/ --out junit > audit.xml

Examples

Run any example:

cargo run --example basic
cargo run --example blog

Compared with other generators

The table below is a capability comparison, not a benchmark; for build times see Benchmarks.

---