diff --git a/generated/cargo-gpu/Cargo.toml b/generated/graphics/cargo-gpu/Cargo.toml
similarity index 100%
rename from generated/cargo-gpu/Cargo.toml
rename to generated/graphics/cargo-gpu/Cargo.toml
diff --git a/generated/cargo-gpu/ash/Cargo.toml b/generated/graphics/cargo-gpu/ash/Cargo.toml
similarity index 100%
rename from generated/cargo-gpu/ash/Cargo.toml
rename to generated/graphics/cargo-gpu/ash/Cargo.toml
diff --git a/generated/cargo-gpu/ash/build.rs b/generated/graphics/cargo-gpu/ash/build.rs
similarity index 100%
rename from generated/cargo-gpu/ash/build.rs
rename to generated/graphics/cargo-gpu/ash/build.rs
diff --git a/generated/cargo-gpu/ash/src/device.rs b/generated/graphics/cargo-gpu/ash/src/device.rs
similarity index 100%
rename from generated/cargo-gpu/ash/src/device.rs
rename to generated/graphics/cargo-gpu/ash/src/device.rs
diff --git a/generated/cargo-gpu/ash/src/graphics.rs b/generated/graphics/cargo-gpu/ash/src/graphics.rs
similarity index 100%
rename from generated/cargo-gpu/ash/src/graphics.rs
rename to generated/graphics/cargo-gpu/ash/src/graphics.rs
diff --git a/generated/cargo-gpu/ash/src/main.rs b/generated/graphics/cargo-gpu/ash/src/main.rs
similarity index 100%
rename from generated/cargo-gpu/ash/src/main.rs
rename to generated/graphics/cargo-gpu/ash/src/main.rs
diff --git a/generated/cargo-gpu/ash/src/single_command_buffer.rs b/generated/graphics/cargo-gpu/ash/src/single_command_buffer.rs
similarity index 100%
rename from generated/cargo-gpu/ash/src/single_command_buffer.rs
rename to generated/graphics/cargo-gpu/ash/src/single_command_buffer.rs
diff --git a/generated/cargo-gpu/ash/src/swapchain.rs b/generated/graphics/cargo-gpu/ash/src/swapchain.rs
similarity index 100%
rename from generated/cargo-gpu/ash/src/swapchain.rs
rename to generated/graphics/cargo-gpu/ash/src/swapchain.rs
diff --git a/generated/cargo-gpu/shaders/Cargo.toml b/generated/graphics/cargo-gpu/shaders/Cargo.toml
similarity index 100%
rename from generated/cargo-gpu/shaders/Cargo.toml
rename to generated/graphics/cargo-gpu/shaders/Cargo.toml
diff --git a/generated/cargo-gpu/shaders/src/lib.rs b/generated/graphics/cargo-gpu/shaders/src/lib.rs
similarity index 100%
rename from generated/cargo-gpu/shaders/src/lib.rs
rename to generated/graphics/cargo-gpu/shaders/src/lib.rs
diff --git a/generated/spirv-builder/Cargo.toml b/generated/graphics/spirv-builder/Cargo.toml
similarity index 100%
rename from generated/spirv-builder/Cargo.toml
rename to generated/graphics/spirv-builder/Cargo.toml
diff --git a/generated/spirv-builder/ash/Cargo.toml b/generated/graphics/spirv-builder/ash/Cargo.toml
similarity index 100%
rename from generated/spirv-builder/ash/Cargo.toml
rename to generated/graphics/spirv-builder/ash/Cargo.toml
diff --git a/generated/spirv-builder/ash/build.rs b/generated/graphics/spirv-builder/ash/build.rs
similarity index 100%
rename from generated/spirv-builder/ash/build.rs
rename to generated/graphics/spirv-builder/ash/build.rs
diff --git a/generated/spirv-builder/ash/src/device.rs b/generated/graphics/spirv-builder/ash/src/device.rs
similarity index 100%
rename from generated/spirv-builder/ash/src/device.rs
rename to generated/graphics/spirv-builder/ash/src/device.rs
diff --git a/generated/spirv-builder/ash/src/graphics.rs b/generated/graphics/spirv-builder/ash/src/graphics.rs
similarity index 100%
rename from generated/spirv-builder/ash/src/graphics.rs
rename to generated/graphics/spirv-builder/ash/src/graphics.rs
diff --git a/generated/spirv-builder/ash/src/main.rs b/generated/graphics/spirv-builder/ash/src/main.rs
similarity index 100%
rename from generated/spirv-builder/ash/src/main.rs
rename to generated/graphics/spirv-builder/ash/src/main.rs
diff --git a/generated/spirv-builder/ash/src/single_command_buffer.rs b/generated/graphics/spirv-builder/ash/src/single_command_buffer.rs
similarity index 100%
rename from generated/spirv-builder/ash/src/single_command_buffer.rs
rename to generated/graphics/spirv-builder/ash/src/single_command_buffer.rs
diff --git a/generated/spirv-builder/ash/src/swapchain.rs b/generated/graphics/spirv-builder/ash/src/swapchain.rs
similarity index 100%
rename from generated/spirv-builder/ash/src/swapchain.rs
rename to generated/graphics/spirv-builder/ash/src/swapchain.rs
diff --git a/generated/spirv-builder/rust-toolchain.toml b/generated/graphics/spirv-builder/rust-toolchain.toml
similarity index 100%
rename from generated/spirv-builder/rust-toolchain.toml
rename to generated/graphics/spirv-builder/rust-toolchain.toml
diff --git a/generated/spirv-builder/shaders/Cargo.toml b/generated/graphics/spirv-builder/shaders/Cargo.toml
similarity index 100%
rename from generated/spirv-builder/shaders/Cargo.toml
rename to generated/graphics/spirv-builder/shaders/Cargo.toml
diff --git a/generated/spirv-builder/shaders/src/lib.rs b/generated/graphics/spirv-builder/shaders/src/lib.rs
similarity index 100%
rename from generated/spirv-builder/shaders/src/lib.rs
rename to generated/graphics/spirv-builder/shaders/src/lib.rs
diff --git a/xtask/Cargo.lock b/xtask/Cargo.lock
index e952cd5..7d65b19 100644
--- a/xtask/Cargo.lock
+++ b/xtask/Cargo.lock
@@ -1866,27 +1866,6 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "strum"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
-dependencies = [
- "strum_macros",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.111"
@@ -2482,8 +2461,10 @@ dependencies = [
  "cargo-generate",
  "clap",
  "env_logger",
+ "indexmap",
  "log",
- "strum",
+ "serde",
+ "toml",
 ]
 
 [[package]]
diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml
index d07fb0b..86d66ce 100644
--- a/xtask/Cargo.toml
+++ b/xtask/Cargo.toml
@@ -7,7 +7,11 @@ edition = "2024"
 [dependencies]
 anyhow = "1.0.100"
 clap = { version = "4.5.53", features = ["derive"] }
-strum = { version = "0.27.2", features = ["derive"] }
 log = "0.4.28"
 env_logger = "0.11.8"
+
+# deps below are copied from `cargo-generate`
 cargo-generate = { version = "0.23.7", default-features = false, features = [] }
+serde = { version = "~1.0", features = ["derive"] }
+toml = { version = "~0.9", features = ["preserve_order"] }
+indexmap = { version = "~2", features = ["serde"] }
diff --git a/xtask/src/cargo_generate_config.rs b/xtask/src/cargo_generate_config.rs
new file mode 100644
index 0000000..e5da2a2
--- /dev/null
+++ b/xtask/src/cargo_generate_config.rs
@@ -0,0 +1,28 @@
+//! These definitions are copied from `cargo_generate::config`, since that interface isn't pub.
+//! Only keys we need are kept.
+
+use indexmap::IndexMap;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+pub const CONFIG_FILE_NAME: &str = "cargo-generate.toml";
+
+#[derive(Deserialize, Debug, PartialEq, Default, Clone)]
+pub struct Config {
+    pub template: Option<TemplateConfig>,
+    pub placeholders: Option<TemplateSlotsTable>,
+    pub conditional: Option<HashMap<String, ConditionalConfig>>,
+}
+
+#[derive(Deserialize, Debug, PartialEq, Eq, Default, Clone)]
+pub struct TemplateConfig {
+    pub sub_templates: Option<Vec<String>>,
+}
+
+#[derive(Deserialize, Debug, PartialEq, Clone)]
+pub struct ConditionalConfig {
+    pub placeholders: Option<TemplateSlotsTable>,
+}
+
+#[derive(Deserialize, Debug, PartialEq, Clone, Default)]
+pub struct TemplateSlotsTable(pub IndexMap<String, toml::Value>);
diff --git a/xtask/src/generate.rs b/xtask/src/generate.rs
index 423b629..9130781 100644
--- a/xtask/src/generate.rs
+++ b/xtask/src/generate.rs
@@ -1,130 +1,267 @@
-use anyhow::Context;
+use crate::cargo_generate_config::{CONFIG_FILE_NAME, Config};
+use anyhow::{Context, bail};
 use cargo_generate::GenerateArgs;
 use clap::Parser;
-use clap::builder::PossibleValue;
+use indexmap::IndexMap;
 use log::{debug, info};
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fmt::{Debug, Display, Formatter};
 use std::path::{Path, PathBuf};
-use strum::{Display, EnumString, IntoStaticStr, VariantArray};
-
-pub const TEMPLATE_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../graphics");
-
-/// All possible placeholder *values*.
-///
-/// We assume there are no duplicate values for placeholders, so we don't need to type out the key / placeholder name,
-/// but can derive the key from the value directly.
-#[repr(u32)]
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Display, EnumString, IntoStaticStr, VariantArray)]
-pub enum Values {
-    #[strum(to_string = "cargo-gpu")]
-    CargoGpu,
-    #[strum(to_string = "spirv-builder")]
-    SpirvBuilder,
+
+#[derive(Parser, Debug, Default)]
+pub struct Generate {
+    /// Directory where to place the generated templates.
+    #[clap(long)]
+    out: Option<PathBuf>,
+    /// Clean generate, deletes the generated directory before generating templates. Use this when you moved or removed
+    /// files.
+    #[clap(long)]
+    clean: bool,
+    /// A command that should be executed on each generated template.
+    ///
+    /// If a command fails, this process will fail as well, allowing you to test the template output.
+    #[clap(long, short = 'x')]
+    execute: Option<String>,
+    /// Filter for values that any placeholder accepts
+    ///
+    /// We assume there are no values that two different placeholders match, within a single template, so we don't have
+    /// to specify the placeholder the value is associated to.
+    filter: Vec<String>,
 }
 
-impl Debug for Values {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(self, f)
-    }
+#[derive(Clone, Debug)]
+struct TemplateDiscovery {
+    templates: Vec<Template>,
 }
 
-impl clap::ValueEnum for Values {
-    fn value_variants<'a>() -> &'a [Self] {
-        Values::VARIANTS
+impl TemplateDiscovery {
+    pub const TEMPLATE_PATH: &'static str = concat!(env!("CARGO_MANIFEST_DIR"), "/..");
+
+    fn discover() -> anyhow::Result<Self> {
+        Self::discover_at(Path::new(Self::TEMPLATE_PATH))
     }
 
-    fn to_possible_value(&self) -> Option<PossibleValue> {
-        Some(PossibleValue::new(self.value()))
+    /// Our discovery is not as dynamic as `cargo_generate`, written to be just sufficient for this repo and to be
+    /// *fast*, even with a large target directory. Primarily, that means not scanning through the entire dir tree,
+    /// instead just using the paths that are explicitly defined in the config.
+    /// https://github.com/cargo-generate/cargo-generate/issues/1600
+    fn discover_at(base_dir: &Path) -> anyhow::Result<Self> {
+        let sub_templates = {
+            let root_file = base_dir.join(CONFIG_FILE_NAME);
+            let root: Config = toml::from_str(&std::fs::read_to_string(&root_file)?)?;
+            let root_template = root
+                .template
+                .with_context(|| format!("Expected `template` in `{}`", root_file.display()))?;
+            root_template.sub_templates.unwrap_or_else(Vec::new)
+        };
+
+        let templates = sub_templates
+            .into_iter()
+            .map(|name| {
+                let template_dir = base_dir.join(&name);
+                Template::parse(name, template_dir)
+            })
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        let discovery = Self { templates };
+        debug!("Discovery found: {discovery:#?}");
+        Ok(discovery)
     }
-}
 
-impl Values {
-    pub fn key(&self) -> Placeholders {
-        match self {
-            Values::CargoGpu | Values::SpirvBuilder => Placeholders::Integration,
+    fn split_filter<'a>(&self, filters: impl Iterator<Item = &'a str>) -> Filters<'a> {
+        let mut out = Filters::default();
+        for filter in filters {
+            if self.templates.iter().any(|t| t.name == filter) {
+                out.template_filters.insert(filter);
+            } else {
+                out.placeholder_filters.push(filter);
+            }
         }
+        debug!("Filters: {out:?}");
+        out
     }
 
-    pub fn value(&self) -> &'static str {
-        <&'static str>::from(self)
+    fn filter_variants<'a>(
+        &'a self,
+        filters: impl Iterator<Item = &'a str>,
+    ) -> anyhow::Result<Vec<(&'a Template, Vec<Define<'a>>)>> {
+        let filters = self.split_filter(filters);
+
+        let mut has_unknown_filter = true;
+        let mut unknown_filter = None;
+        let variants = self
+            .templates
+            .iter()
+            .filter(|template| {
+                filters.template_filters.is_empty()
+                    || filters.template_filters.contains(template.name.as_str())
+            })
+            .flat_map(|template| {
+                let variants_result =
+                    template.variants(filters.placeholder_filters.iter().copied());
+                let variants = match variants_result {
+                    Ok(e) => {
+                        has_unknown_filter = false;
+                        e
+                    }
+                    Err(e) => {
+                        unknown_filter = Some(e);
+                        Vec::new()
+                    }
+                };
+                variants.into_iter().map(move |v| (template, v))
+            })
+            .collect::<Vec<_>>();
+        if has_unknown_filter {
+            if let Some(filter) = unknown_filter {
+                bail!("Unknown filter `{filter}`")
+            } else {
+                // Only reachable if no templates exist, Or if all templates have been filtered out, but you must filter
+                // for at least one template for template filtering to even activate, so should be unreachable.
+                bail!("No templates exist?")
+            }
+        }
+        debug!("Variants: {variants:?}");
+        Ok(variants)
     }
 }
 
-#[repr(u32)]
-#[derive(Copy, Clone, Eq, PartialEq, Hash, Display, EnumString, IntoStaticStr, VariantArray)]
-pub enum Placeholders {
-    #[strum(to_string = "integration")]
-    Integration,
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+struct Filters<'a> {
+    template_filters: HashSet<&'a str>,
+    /// value whether it was used
+    placeholder_filters: Vec<&'a str>,
+}
+
+#[derive(Clone, Debug)]
+struct Template {
+    name: String,
+    template_dir: PathBuf,
+    placeholders: IndexMap<String, Vec<String>>,
+}
+
+#[derive(Copy, Clone, Eq, PartialEq)]
+struct Define<'a> {
+    key: &'a str,
+    value: &'a str,
 }
 
-impl Debug for Placeholders {
+impl Display for Define<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(self, f)
+        write!(f, "{}={}", self.key, self.value)
     }
 }
 
-#[derive(Parser, Debug, Default)]
-pub struct Generate {
-    /// Directory where to place the generated templates.
-    #[clap(long)]
-    out: Option<PathBuf>,
-    /// Clean generate, deletes the generated directory before generating templates. Use this when you moved or removed
-    /// files.
-    #[clap(long)]
-    clean: bool,
-    /// A command that should be executed on each generated template.
-    ///
-    /// If a command fails, this process will fail as well, allowing you to test the template output.
-    #[clap(long, short = 'x')]
-    execute: Option<String>,
-    values: Vec<Values>,
+impl Debug for Define<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(self, f)
+    }
 }
 
-impl Generate {
+impl Template {
+    fn parse(name: String, template_dir: PathBuf) -> anyhow::Result<Self> {
+        let config_file = template_dir.join(CONFIG_FILE_NAME);
+        let config: Config = toml::from_str(&std::fs::read_to_string(&config_file)?)?;
+        let placeholders = config
+            .placeholders
+            .with_context(|| format!("Expected `placeholders` in `{}`", config_file.display()))?
+            .0;
+        let placeholders = placeholders
+            .into_iter()
+            .map(|(p, toml)| {
+                let choices = toml.get("choices").with_context(|| {
+                    format!(
+                        "Expected `placeholders.{p}` in `{}` to have `choices` set",
+                        config_file.display()
+                    )
+                })?;
+                let choices = choices.as_array().with_context(|| {
+                    format!(
+                        "Expected `placeholders.{p}.choices` in `{}` to be an array",
+                        config_file.display()
+                    )
+                })?;
+                let choices =
+                    choices
+                        .iter()
+                        .enumerate()
+                        .map(|(i, c)| {
+                            let c = c.as_str().with_context(|| format!(
+                                "Expected `placeholders.{p}.choices[{i}]` in `{}` to be a string",
+                                config_file.display()
+                            ))?;
+                            Ok(c.to_string())
+                        })
+                        .collect::<anyhow::Result<Vec<_>>>()?;
+                Ok((p, choices))
+            })
+            .collect::<anyhow::Result<IndexMap<_, _>>>()?;
+        Ok(Self {
+            name,
+            template_dir,
+            placeholders,
+        })
+    }
+
+    fn value_to_placeholder(&self) -> HashMap<&str, &str> {
+        self.placeholders
+            .iter()
+            .flat_map(|(key, values)| values.iter().map(|v| (v.as_str(), key.as_str())))
+            .collect()
+    }
+
     /// Computes all template variants to expand to and returns them in a Vec.
     /// The inner vec is guaranteed to contain no duplicate [`Placeholders`] and is sorted by order of the
-    /// [`Placeholders`] in the enum.
-    fn variants(&self) -> Vec<Vec<Values>> {
+    /// [`Placeholders`] in the enum. Returns an error if a filter was not found.
+    fn variants<'a>(
+        &'a self,
+        filter: impl Iterator<Item = &'a str>,
+    ) -> Result<Vec<Vec<Define<'a>>>, &'a str> {
         // insert all Placeholders with empty Vec for possible values
-        let mut variant_map: HashMap<Placeholders, Vec<Values>> = Placeholders::VARIANTS
+        let mut variant_map: IndexMap<&str, Vec<&str>> = self
+            .placeholders
             .iter()
-            .map(|p| (*p, Vec::new()))
+            .map(|(p, _)| (p.as_str(), Vec::new()))
             .collect();
 
         // push all values supplied by args into their respective Placeholder's Vec
-        for v in self.values.iter().copied() {
-            variant_map.get_mut(&v.key()).unwrap().push(v);
+        let mut filter = filter.peekable();
+        if filter.peek().is_some() {
+            let value_to_key = self.value_to_placeholder();
+            for v in filter {
+                let key = value_to_key.get(v).ok_or(v)?;
+                variant_map.get_mut(key).unwrap().push(v);
+            }
         }
 
         // cross product of all Placeholder keys
-        let mut variants: Vec<Vec<Values>> = Vec::from(&[Vec::new()]);
+        let mut variants: Vec<Vec<Define>> = Vec::from(&[Vec::new()]);
         for (p, mut values) in variant_map.into_iter() {
             // if some Placeholders don't have any values -> all possible values
             if values.is_empty() {
-                values = Values::VARIANTS
-                    .iter()
-                    .copied()
-                    .filter(|v| v.key() == p)
-                    .collect();
+                let all = self.placeholders.get(p).unwrap();
+                values = all.iter().map(|s| s.as_str()).collect::<Vec<_>>();
             }
             assert!(!values.is_empty());
-            values.sort_by_key(|v| v.key() as u32);
 
             variants = values
                 .into_iter()
                 .flat_map(|add| {
-                    variants
-                        .iter()
-                        .map(move |v| v.iter().copied().chain([add]).collect::<Vec<_>>())
+                    variants.iter().map(move |v| {
+                        v.iter()
+                            .copied()
+                            .chain([Define { key: p, value: add }])
+                            .collect::<Vec<_>>()
+                    })
                 })
                 .collect::<Vec<_>>();
         }
 
-        debug!("Computed variants: {variants:?}");
-        variants
+        debug!("Variants for template `{}`: {variants:?}", self.name);
+        Ok(variants)
     }
+}
 
+impl Generate {
     fn out_base_dir(&self) -> anyhow::Result<PathBuf> {
         let out = self
             .out
@@ -138,6 +275,8 @@ impl Generate {
         Ok(out)
     }
 
+    /// Some params can't be normalized with `--define`
+    /// https://github.com/cargo-generate/cargo-generate/issues/1602
     fn normalize_env(&self) {
         // Safety: xtask generate is not multithreaded
         unsafe {
@@ -146,11 +285,16 @@ impl Generate {
         }
     }
 
-    fn generate(&self, out_base_dir: &Path, variant: &[Values]) -> anyhow::Result<PathBuf> {
+    fn generate(
+        &self,
+        out_base_dir: &Path,
+        template: &Template,
+        variant: &[Define],
+    ) -> anyhow::Result<PathBuf> {
         let out_dir = {
             let mut out_dir = PathBuf::from(out_base_dir);
             for value in variant {
-                out_dir.push(value.value());
+                out_dir.push(value.value);
             }
             std::fs::create_dir_all(&out_dir)?;
             out_dir
@@ -158,13 +302,11 @@ impl Generate {
 
         debug!("Generating `{variant:?}` at `{}`", out_dir.display());
         let mut args = GenerateArgs::default();
-        args.template_path.path = Some(TEMPLATE_PATH.to_string());
+        args.template_path.path = Some(template.template_dir.to_string_lossy().into_owned());
         args.init = true;
         args.overwrite = true;
-        args.define = variant
-            .iter()
-            .map(|v| format!("{}={}", v.key(), v.value()))
-            .collect();
+        args.silent = true;
+        args.define = variant.iter().map(|v| v.to_string()).collect();
         args.name = Some("name-is-ignored".to_string());
         args.destination = Some(out_dir.clone());
         cargo_generate::generate(args)?;
@@ -188,7 +330,7 @@ impl Generate {
                 success &= status.success();
             }
             if !success {
-                anyhow::bail!("Some processes spawned by `--execute` failed");
+                bail!("Some processes spawned by `--execute` failed");
             }
         }
         Ok(())
@@ -197,15 +339,21 @@ impl Generate {
     pub fn run(&self) -> anyhow::Result<()> {
         self.normalize_env();
         let out_base_dir = self.out_base_dir()?;
-        let variants = self.variants();
+
+        let discovery = TemplateDiscovery::discover()?;
+        let variants = discovery.filter_variants(self.filter.iter().map(|a| a.as_str()))?;
         let results = variants
-            .into_iter()
-            .map(|variant| {
-                let out_dir = self.generate(&out_base_dir, &variant)?;
-                Ok((variant, out_dir))
+            .iter()
+            .map(|(template, variants)| {
+                self.generate(&out_base_dir.join(&template.name), template, variants)
             })
             .collect::<anyhow::Result<Vec<_>>>()?;
-        self.execute(results.iter().map(|(_, a)| a.as_path()))?;
+        if results.is_empty() {
+            // reachable with two templates with differing placeholders and filtering for both
+            bail!("Nothing generated, all variants filtered out");
+        }
+
+        self.execute(results.iter().map(|b| b.as_path()))?;
         Ok(())
     }
 }
@@ -214,56 +362,84 @@ impl Generate {
 mod tests {
     use super::*;
 
-    pub fn placeholder_map() -> HashMap<Placeholders, Vec<Values>> {
-        let mut variant_map: HashMap<Placeholders, Vec<Values>> = Placeholders::VARIANTS
-            .iter()
-            .copied()
-            .map(|p| (p, Vec::new()))
-            .collect();
-        for v in Values::VARIANTS.iter().copied() {
-            variant_map.get_mut(&v.key()).unwrap().push(v);
+    const CARGO_GPU: Define = Define {
+        key: "integration",
+        value: "cargo-gpu",
+    };
+    const SPIRV_BUILDER: Define = Define {
+        key: "integration",
+        value: "spirv-builder",
+    };
+    const ASH: Define = Define {
+        key: "api",
+        value: "ash",
+    };
+    const WGPU: Define = Define {
+        key: "api",
+        value: "wgpu",
+    };
+    const CPU: Define = Define {
+        key: "api",
+        value: "cpu",
+    };
+
+    pub fn test_template() -> Template {
+        Template {
+            name: "my-template".to_string(),
+            template_dir: PathBuf::from("./my_template/"),
+            placeholders: IndexMap::from(
+                [
+                    ("integration", ["cargo-gpu", "spirv-builder"].as_slice()),
+                    ("api", ["ash", "wgpu", "cpu"].as_slice()),
+                ]
+                .map(|(k, v)| {
+                    (
+                        k.to_string(),
+                        v.iter().map(|v| v.to_string()).collect::<Vec<_>>(),
+                    )
+                }),
+            ),
         }
-        debug!("placeholder_map: {variant_map:?}");
-        variant_map
     }
 
     #[test]
-    pub fn test_variants_all() {
-        let v_all = Generate {
-            values: Vec::new(),
-            ..Default::default()
-        }
-        .variants();
-        for (p, values) in placeholder_map() {
-            debug!("{p}: {values:?}");
-            assert_eq!(v_all.len() % values.len(), 0);
-            let each_type_count = v_all.len() / values.len();
+    pub fn variants_all() {
+        let template = test_template();
+        let all = template.variants(std::iter::empty()).unwrap();
+        debug!("all: {all:?}");
 
-            for value in values {
-                let vec = v_all
-                    .iter()
-                    .filter(|v| v.contains(&value))
-                    .collect::<Vec<_>>();
-                assert_eq!(
-                    vec.len(),
-                    each_type_count,
-                    "Expected {each_type_count} variants with `{value}`, got {}: {vec:?}",
-                    vec.len()
-                );
-            }
-        }
+        // order *in the outer slice* is arbitrary
+        // order within the inner slice is not, and will affect `generated/` folder structure
+        let expected = [
+            [CARGO_GPU, ASH],
+            [SPIRV_BUILDER, ASH],
+            [CARGO_GPU, WGPU],
+            [SPIRV_BUILDER, WGPU],
+            [CARGO_GPU, CPU],
+            [SPIRV_BUILDER, CPU],
+        ];
+        assert_eq!(all, expected);
     }
 
     #[test]
-    pub fn test_variants_no_duplicates() {
-        let generate = Generate {
-            values: Vec::new(),
-            ..Default::default()
-        };
-        let variants = generate.variants();
+    pub fn variants_cross_product_test() {
+        variants_cross_product(&test_template());
+    }
+
+    #[test]
+    pub fn variants_cross_product_repo() {
+        let discovery = TemplateDiscovery::discover().unwrap();
+        for template in &discovery.templates {
+            debug!("Template {}:", template.name);
+            variants_cross_product(template);
+        }
+    }
+
+    pub fn variants_cross_product(template: &Template) {
+        let variants = template.variants(std::iter::empty()).unwrap();
         for variant in variants {
-            for value in variant.iter().copied() {
-                let value_count = variant.iter().copied().filter(|o| *o == value).count();
+            for value in variant.iter() {
+                let value_count = variant.iter().filter(|o| Define::eq(o, value)).count();
                 assert_eq!(
                     value_count, 1,
                     "Variant `{variant:?}` contains value `{value}` more than once!"
@@ -273,25 +449,90 @@ mod tests {
     }
 
     #[test]
-    pub fn test_variants_filter() {
-        let v_all = Generate {
-            values: Vec::new(),
-            ..Default::default()
+    pub fn variants_filter_test() {
+        variants_filter(&test_template())
+    }
+
+    #[test]
+    pub fn variants_filter_repo() {
+        let discovery = TemplateDiscovery::discover().unwrap();
+        for template in &discovery.templates {
+            debug!("Template {}:", template.name);
+            variants_filter(template);
         }
-        .variants();
-        for (p, values) in placeholder_map() {
+    }
+
+    pub fn variants_filter(template: &Template) {
+        let v_all = template.variants(std::iter::empty()).unwrap();
+        for (p, values) in &template.placeholders {
             debug!("{p}: {values:?}");
             assert_eq!(v_all.len() % values.len(), 0);
             let each_type_count = v_all.len() / values.len();
 
             for i in 1..values.len() {
-                let v_one = Generate {
-                    values: Vec::from(&values[..i]),
-                    ..Default::default()
-                }
-                .variants();
+                let v_one = template
+                    .variants(values[..i].iter().map(|s| s.as_str()))
+                    .unwrap();
                 assert_eq!(v_one.len(), each_type_count * i);
             }
         }
     }
+
+    #[test]
+    pub fn template_filter_all_test() {
+        let discovery = TemplateDiscovery {
+            templates: Vec::from([test_template()]),
+        };
+        let filter = discovery.split_filter(std::iter::empty());
+        assert_eq!(filter, Filters::default());
+        let result = discovery.filter_variants(std::iter::empty()).unwrap();
+        let templates = result
+            .iter()
+            .map(|(t, _)| t.name.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(templates, ["my-template"; 6])
+    }
+
+    #[test]
+    pub fn template_filter_one_test() {
+        let discovery = TemplateDiscovery {
+            templates: Vec::from([test_template()]),
+        };
+        let filter_args = ["my-template"];
+        let filter = discovery.split_filter(filter_args.iter().copied());
+        assert_eq!(
+            filter,
+            Filters {
+                template_filters: HashSet::from(["my-template"]),
+                placeholder_filters: Vec::new(),
+            }
+        );
+        let result = discovery
+            .filter_variants(filter_args.iter().copied())
+            .unwrap();
+        let templates = result
+            .iter()
+            .map(|(t, _)| t.name.as_str())
+            .collect::<Vec<_>>();
+        assert_eq!(templates, ["my-template"; 6])
+    }
+
+    #[test]
+    pub fn template_filter_none_test() {
+        let discovery = TemplateDiscovery {
+            templates: Vec::from([test_template()]),
+        };
+        let filter_args = ["unknown"];
+        let filter = discovery.split_filter(filter_args.iter().copied());
+        assert_eq!(
+            filter,
+            Filters {
+                template_filters: HashSet::default(),
+                placeholder_filters: Vec::from(["unknown"]),
+            }
+        );
+        let result = discovery.filter_variants(filter_args.iter().copied());
+        // Unknown filter
+        assert!(result.is_err(), "Result: {result:#?}");
+    }
 }
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index c4460f3..da952cb 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -2,6 +2,7 @@ use crate::generate::Generate;
 use clap::Parser;
 use log::debug;
 
+pub mod cargo_generate_config;
 mod generate;
 
 #[derive(Parser, Debug)]