3 files changed, 97 insertions, 8 deletions

diff --git a/release/src/build.rs b/release/src/build.rs
index adf251b4d..d1abb2aa1 100644
--- a/release/src/build.rs
+++ b/release/src/build.rs
@@ -1,5 +1,46 @@
 use anyhow::Result;
 
-pub(crate) fn build(ctx: &crate::Context) -> Result<()> {
-    todo!()
+use crate::cargo::{CargoArgsBuilder, CargoBatchBuilder};
+
+pub(crate) fn build(ctx: &crate::Context, crate_name: Option<&str>) -> Result<()> {
+    let mut batch_builder = CargoBatchBuilder::new();
+
+    // Process either specific crate or all crates
+    let crates_to_build: Vec<_> = if let Some(name) = crate_name {
+        // Build only the specified crate
+        if let Some(krate) = ctx.crates.get(name) {
+            vec![krate]
+        } else {
+            return Err(anyhow::anyhow!("Crate '{}' not found", name));
+        }
+    } else {
+        // Build all crates
+        ctx.crates.values().collect()
+    };
+
+    // Process selected crates and add their build configurations to the batch
+    for krate in crates_to_build {
+        for config in &krate.configs {
+            let mut args_builder = CargoArgsBuilder::new()
+                .subcommand("build")
+                .arg("--release")
+                .arg(format!("--manifest-path={}/Cargo.toml", krate.path.to_string_lossy()));
+
+            if let Some(ref target) = config.target {
+                args_builder = args_builder.target(target);
+            }
+
+            if !config.features.is_empty() {
+                args_builder = args_builder.features(&config.features);
+            }
+
+            batch_builder.add_command(args_builder.build());
+        }
+    }
+
+    // Execute the cargo batch command
+    let batch_args = batch_builder.build();
+    crate::cargo::run(&batch_args, &ctx.root)?;
+
+    Ok(())
 }
diff --git a/release/src/cargo.rs b/release/src/cargo.rs
index 1a4f79f20..0b28458e9 100644
--- a/release/src/cargo.rs
+++ b/release/src/cargo.rs
@@ -1,10 +1,8 @@
 //! Tools for working with Cargo.
 
-use std::{
-    ffi::OsStr,
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-};
+use std::ffi::OsStr;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
 
 use anyhow::{bail, Context as _, Result};
 use clap::ValueEnum as _;
@@ -107,6 +105,17 @@ pub struct CargoArgsBuilder {
 
 impl CargoArgsBuilder {
     #[must_use]
+    pub fn new() -> Self {
+        Self {
+            toolchain: None,
+            subcommand: String::new(),
+            target: None,
+            features: vec![],
+            args: vec![],
+        }
+    }
+
+    #[must_use]
     pub fn toolchain<S>(mut self, toolchain: S) -> Self
     where
         S: Into<String>,
@@ -192,3 +201,38 @@ impl CargoArgsBuilder {
         args
     }
 }
+
+#[derive(Debug, Default)]
+pub struct CargoBatchBuilder {
+    commands: Vec<Vec<String>>,
+}
+
+impl CargoBatchBuilder {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { commands: vec![] }
+    }
+
+    #[must_use]
+    pub fn command(mut self, args: Vec<String>) -> Self {
+        self.commands.push(args);
+        self
+    }
+
+    pub fn add_command(&mut self, args: Vec<String>) -> &mut Self {
+        self.commands.push(args);
+        self
+    }
+
+    #[must_use]
+    pub fn build(&self) -> Vec<String> {
+        let mut args = vec!["batch".to_string()];
+
+        for command in &self.commands {
+            args.push("---".to_string());
+            args.extend(command.clone());
+        }
+
+        args
+    }
+}
diff --git a/release/src/main.rs b/release/src/main.rs
index 7850bbb8d..b1bc17255 100644
--- a/release/src/main.rs
+++ b/release/src/main.rs
@@ -134,6 +134,10 @@ fn list_crates(root: &PathBuf) -> Result<BTreeMap<CrateId, Crate>> {
 
                 let metadata = &parsed.package.metadata.embassy;
 
+                if metadata.skip {
+                    continue;
+                }
+
                 let mut dependencies = Vec::new();
                 for (k, _) in parsed.dependencies {
                     if k.starts_with("embassy-") {
@@ -266,7 +270,7 @@ fn main() -> Result<()> {
             }
         }
         Command::Build { crate_name } => {
-            build::build(&ctx)?;
+            build::build(&ctx, crate_name.as_deref())?;
         }
         Command::SemverCheck { crate_name } => {
             let c = ctx.crates.get(&crate_name).unwrap();