diff --git a/CHANGELOG.md b/CHANGELOG.md
index 42c098b..52f4197 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,13 +8,19 @@
   - All templates now use `finalAttrs` pattern instead of `rec` for better override composition
 
 - Additions:
-  - Modern `finalAttrs` pattern is now default for all package templates (stdenv, Python, Rust, Go, npm, pnpm)
+  - Modern `finalAttrs` pattern is now default for all package templates (stdenv, Python, Rust, Go, npm, pnpm, dotnet)
   - Self-references now use `finalAttrs.pname` and `finalAttrs.version`
   - PyPI fetcher uses `inherit (finalAttrs) pname version;` syntax
   - Added `npm` template for Node.js packages using buildNpmPackage
   - Added `pnpm` template for pnpm-based packages using fetchPnpmDeps with stdenv.mkDerivation
+  - Added `dotnet` template for .NET packages using buildDotnetModule
+  - Added `ruby` template for Ruby applications using bundlerApp
   - Dependency hash prefetching now supports npm and pnpm templates (requires package-lock.json/pnpm-lock.yaml in repository)
+  - Dependency inference for ruby template from Gemfile.lock (maps common gems like nokogiri, pg, mysql2 to their nixpkgs dependencies)
   - Auto-detection now recognizes npm and pnpm projects (via pnpm-lock.yaml, package-lock.json, or package.json)
+  - Auto-detection now recognizes .NET projects (via *.csproj, *.fsproj, or *.sln files)
+  - Auto-detection now recognizes Ruby projects (via Gemfile.lock or Gemfile)
+  - Project file inference for dotnet template when using --from-url (automatically detects .csproj, .fsproj, or .sln)
 
 ## v0.4.1
 
diff --git a/src/cli.rs b/src/cli.rs
index e414934..cf617d4 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -4,9 +4,10 @@ use std::io::IsTerminal;
 use crate::file_path::nix_file_paths;
 use crate::interactive::InteractiveData;
 use crate::go_deps::infer_go_dependencies;
+use crate::ruby_deps;
 use crate::rust_deps::infer_rust_dependencies;
 use crate::types::{ExpressionInfo, Fetcher, Template, UserConfig, FAKE_SRI_HASH};
-use crate::url::{prefetch_dependency_hash, read_meta_from_url};
+use crate::url::{infer_dotnet_project_file, prefetch_dependency_hash, read_meta_from_url};
 
 // clap will validate inputs, only use on functions with possible_values defined
 pub fn arg_to_type<T>(arg: Option<&str>) -> T
@@ -282,6 +283,7 @@ pub fn validate_and_serialize_matches(
         vendor_hash: FAKE_SRI_HASH.to_owned(),
         npm_deps_hash: FAKE_SRI_HASH.to_owned(),
         pnpm_deps_hash: FAKE_SRI_HASH.to_owned(),
+        project_file: "CHANGE".to_owned(),
         domain: "CHANGE".to_owned(),
         build_inputs: Vec::new(),
         native_build_inputs: Vec::new(),
@@ -358,7 +360,7 @@ pub fn validate_and_serialize_matches(
         }
     }
 
-    // Inference is on by default for the rust and go templates whenever we
+    // Inference is on by default for the rust, go, and ruby templates whenever we
     // have a real source to inspect. Users can disable via `--skip-infer-deps`.
     let infer_enabled = matches.is_present("from-url")
         && !matches.is_present("skip-infer-deps");
@@ -376,6 +378,14 @@ pub fn validate_and_serialize_matches(
                     info.native_build_inputs = native;
                 }
             }
+            Template::ruby => {
+                ruby_deps::infer_dependencies(&mut info);
+            }
+            Template::dotnet => {
+                if let Some(project_file) = infer_dotnet_project_file(&info) {
+                    info.project_file = project_file;
+                }
+            }
             _ => {}
         }
     }
@@ -444,6 +454,7 @@ pub fn build_expression_info_from_interactive(
         vendor_hash: FAKE_SRI_HASH.to_owned(),
         npm_deps_hash: FAKE_SRI_HASH.to_owned(),
         pnpm_deps_hash: FAKE_SRI_HASH.to_owned(),
+        project_file: "CHANGE".to_owned(),
         domain: "CHANGE".to_owned(),
         build_inputs: Vec::new(),
         native_build_inputs: Vec::new(),
@@ -479,6 +490,14 @@ pub fn build_expression_info_from_interactive(
                     info.native_build_inputs = native;
                 }
             }
+            Template::ruby => {
+                ruby_deps::infer_dependencies(&mut info);
+            }
+            Template::dotnet => {
+                if let Some(project_file) = infer_dotnet_project_file(&info) {
+                    info.project_file = project_file;
+                }
+            }
             _ => {}
         }
     }
diff --git a/src/detect.rs b/src/detect.rs
index 48a5d86..c5e07b5 100644
--- a/src/detect.rs
+++ b/src/detect.rs
@@ -30,6 +30,8 @@ const INDICATORS: &[(&str, Template, &str)] = &[
     ("pnpm-lock.yaml", Template::pnpm, "pnpm-lock.yaml"),
     ("package-lock.json", Template::npm, "package-lock.json"),
     // Note: package.json is handled separately as a fallback (see below)
+    ("Gemfile.lock", Template::ruby, "Gemfile.lock"),
+    ("Gemfile", Template::ruby, "Gemfile"),
     ("meson.build", Template::stdenv, "meson.build"),
     ("CMakeLists.txt", Template::stdenv, "CMakeLists.txt"),
     ("configure", Template::stdenv, "configure"),
@@ -88,9 +90,44 @@ pub fn detect_template_candidates_from_path(source_path: &Path) -> Vec<Candidate
         });
     }
 
+    // .NET detection: scan for .csproj, .fsproj, or .sln files
+    // These files have dynamic names (e.g., MyProject.csproj), so we need to scan the directory.
+    let has_dotnet = candidates
+        .iter()
+        .any(|c| c.template == Template::dotnet);
+
+    if !has_dotnet {
+        if let Some(reason) = find_dotnet_project_file(source_path) {
+            candidates.push(Candidate {
+                template: Template::dotnet,
+                reason,
+            });
+        }
+    }
+
     candidates
 }
 
+/// Scan a directory for .NET project files (.csproj, .fsproj, .sln).
+/// Returns the reason string (file type found) or None if no project files exist.
+fn find_dotnet_project_file(source_path: &Path) -> Option<&'static str> {
+    use std::fs;
+
+    if let Ok(entries) = fs::read_dir(source_path) {
+        for entry in entries.flatten() {
+            if let Some(ext) = entry.path().extension().and_then(|s| s.to_str()) {
+                match ext {
+                    "csproj" => return Some("*.csproj"),
+                    "fsproj" => return Some("*.fsproj"),
+                    "sln" => return Some("*.sln"),
+                    _ => {}
+                }
+            }
+        }
+    }
+    None
+}
+
 /// Detect template candidates by materialising a remote source tree.
 ///
 /// If the fetcher is PyPI, short-circuits without materialising (we already
@@ -321,4 +358,78 @@ mod tests {
         assert_eq!(candidates[0].template, Template::rust);
         assert_eq!(candidates[1].template, Template::npm);
     }
+
+    #[test]
+    fn detect_dotnet_from_csproj() {
+        let dir = make_source_dir(&["MyProject.csproj", "Program.cs"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::dotnet);
+        assert_eq!(candidates[0].reason, "*.csproj");
+    }
+
+    #[test]
+    fn detect_dotnet_from_fsproj() {
+        let dir = make_source_dir(&["MyProject.fsproj", "Program.fs"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::dotnet);
+        assert_eq!(candidates[0].reason, "*.fsproj");
+    }
+
+    #[test]
+    fn detect_dotnet_from_sln() {
+        let dir = make_source_dir(&["MySolution.sln", "README.md"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::dotnet);
+        assert_eq!(candidates[0].reason, "*.sln");
+    }
+
+    #[test]
+    fn detect_multiple_with_dotnet() {
+        let dir = make_source_dir(&["Cargo.toml", "MyProject.csproj"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 2);
+        assert_eq!(candidates[0].template, Template::rust);
+        assert_eq!(candidates[1].template, Template::dotnet);
+    }
+
+    #[test]
+    fn detect_ruby_from_gemfile_lock() {
+        let dir = make_source_dir(&["Gemfile", "Gemfile.lock", "lib/app.rb"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::ruby);
+        assert_eq!(candidates[0].reason, "Gemfile.lock");
+    }
+
+    #[test]
+    fn detect_ruby_from_gemfile_fallback() {
+        let dir = make_source_dir(&["Gemfile", "lib/app.rb"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::ruby);
+        assert_eq!(candidates[0].reason, "Gemfile");
+    }
+
+    #[test]
+    fn detect_multiple_with_ruby() {
+        let dir = make_source_dir(&["Cargo.toml", "Gemfile"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 2);
+        assert_eq!(candidates[0].template, Template::rust);
+        assert_eq!(candidates[1].template, Template::ruby);
+    }
+
+    #[test]
+    fn deduplicate_ruby_indicators() {
+        // When both Gemfile.lock and Gemfile exist, only Gemfile.lock should be kept
+        let dir = make_source_dir(&["Gemfile", "Gemfile.lock"]);
+        let candidates = detect_template_candidates_from_path(dir.path());
+        assert_eq!(candidates.len(), 1);
+        assert_eq!(candidates[0].template, Template::ruby);
+        // Gemfile.lock has higher priority than Gemfile
+        assert_eq!(candidates[0].reason, "Gemfile.lock");
+    }
 }
diff --git a/src/expression.rs b/src/expression.rs
index 0916f81..c19d4f7 100644
--- a/src/expression.rs
+++ b/src/expression.rs
@@ -22,6 +22,8 @@ fn derivation_helper(info: &ExpressionInfo) -> (String, String) {
         Template::rust => ("rustPlatform", "rustPlatform.buildRustPackage", None),
         Template::npm => ("buildNpmPackage", "buildNpmPackage", Some("buildNpmPackage")),
         Template::pnpm => ("stdenv", "stdenv.mkDerivation", Some("stdenvMkDerivation")),
+        Template::dotnet => ("buildDotnetModule", "buildDotnetModule", Some("buildDotnetModule")),
+        Template::ruby => ("bundlerApp", "bundlerApp", Some("bundlerApp")),
         Template::test => ("", "", None),  // Tests aren't a normal expression
         Template::module => ("", "", None), // Modules aren't a normal expression
     };
@@ -159,6 +161,27 @@ fn build_inputs(info: &ExpressionInfo) -> String {
     hash = \"@pnpm_deps_hash@\";
   };".to_owned()
         }
+        Template::dotnet => {
+            "  projectFile = \"@project_file@\";\n  nugetDeps = ./deps.json;  # Run `nix-build -A package-name.passthru.fetch-deps` to generate".to_owned()
+        }
+        Template::ruby => {
+            // Conditionally render build inputs only when inferred
+            let native = if info.native_build_inputs.is_empty() {
+                String::new()
+            } else {
+                "\n  nativeBuildInputs = [@native_build_inputs@ ];".to_owned()
+            };
+            let build = if info.build_inputs.is_empty() {
+                String::new()
+            } else {
+                "\n  buildInputs = [@build_inputs@ ];".to_owned()
+            };
+            format!(
+                "  gemdir = ./.;\n  exes = [ \"@pname@\" ];  # To build this package, you need Gemfile, Gemfile.lock, and gemset.nix in this directory{native}{build}\n",
+                native = native,
+                build = build,
+            )
+        }
         // stdenv / stdenvNoCC: render `nativeBuildInputs` only when
         // populated (via --native-build-inputs); always render
         // `buildInputs` to preserve the existing template's ergonomic
@@ -262,6 +285,34 @@ mkShell rec {
 }
 "
         .to_string(),
+        Template::ruby => {
+            let (_, dh_block) = derivation_helper(info);
+            let meta_content = if info.include_meta { meta() } else { "" };
+
+            let mut inputs = vec![String::from("lib"), String::from("bundlerApp")];
+
+            // Add inferred system dependencies to function header
+            inputs.extend(info.native_build_inputs.iter().map(|s| s.to_owned()));
+            inputs.extend(info.build_inputs.iter().map(|s| s.to_owned()));
+
+            let input_list = inputs.join("\n, ");
+            let header = format!("{{ {input_list}\n}}:", input_list = input_list);
+
+            info.format(&format!(
+                "{header}
+
+{dh_helper} {{
+  pname = \"{pname}\";
+{build_inputs}{meta}
+}}
+",
+                header = header,
+                dh_helper = dh_block,
+                pname = &info.pname,
+                build_inputs = build_inputs(info),
+                meta = meta_content,
+            ))
+        }
         _ => {
             // Generate nix expression
             let (dh_input, dh_block) = derivation_helper(info);
@@ -350,6 +401,7 @@ mod tests {
             vendor_hash: "sha256-vendor".to_owned(),
             npm_deps_hash: "sha256-npm".to_owned(),
             pnpm_deps_hash: "sha256-pnpm".to_owned(),
+            project_file: "Project.csproj".to_owned(),
             domain: "".to_owned(),
             build_inputs: Vec::new(),
             native_build_inputs: Vec::new(),
@@ -391,6 +443,7 @@ mod tests {
             vendor_hash: "".to_owned(),
             npm_deps_hash: "".to_owned(),
             pnpm_deps_hash: "".to_owned(),
+            project_file: "".to_owned(),
             domain: "".to_owned(),
             build_inputs: Vec::new(),
             native_build_inputs: Vec::new(),
diff --git a/src/interactive.rs b/src/interactive.rs
index 13c0c42..9a2b938 100644
--- a/src/interactive.rs
+++ b/src/interactive.rs
@@ -357,6 +357,8 @@ pub fn prompt_template_type(default: Option<Template>) -> Result<Template> {
         ("go", "Go package with buildGoModule"),
         ("npm", "Node.js package with buildNpmPackage"),
         ("pnpm", "Node.js package with pnpm (stdenv + fetchPnpmDeps)"),
+        ("dotnet", ".NET package with buildDotnetModule"),
+        ("ruby", "Ruby application with bundlerApp"),
         ("mkshell", "Development shell.nix"),
         ("module", "NixOS module"),
         ("test", "NixOS test"),
diff --git a/src/main.rs b/src/main.rs
index 786a83c..04d8fd6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,6 +7,7 @@ mod expression;
 mod file_path;
 mod go_deps;
 mod interactive;
+mod ruby_deps;
 mod rust_deps;
 mod source;
 mod types;
diff --git a/src/ruby_deps.rs b/src/ruby_deps.rs
new file mode 100644
index 0000000..1b696e2
--- /dev/null
+++ b/src/ruby_deps.rs
@@ -0,0 +1,287 @@
+//! Inference of Ruby gem → nixpkgs build inputs.
+//!
+//! This module reads a Ruby project's `Gemfile.lock`, walks the gem
+//! specifications, and maps well-known gems with native extensions to
+//! the corresponding nixpkgs `buildInputs` and `nativeBuildInputs` entries.
+//!
+//! The mapping is deliberately conservative: only well-known gems are mapped.
+//! Users can edit the generated expression to add anything we missed.
+
+use crate::types::ExpressionInfo;
+use log::debug;
+use std::collections::BTreeSet;
+
+const LOG_TARGET: &str = "nix-template::ruby_deps";
+
+/// Static mapping from a gem name to its nixpkgs (`buildInputs`,
+/// `nativeBuildInputs`) requirements.
+///
+/// Each tuple is `(build_inputs, native_build_inputs)`. Use `&[]` for
+/// "no extra entries".
+fn lookup_gem(name: &str) -> Option<(&'static [&'static str], &'static [&'static str])> {
+    match name {
+        // XML/HTML parsing
+        "nokogiri" => Some((&["libxml2", "libxslt"], &["pkg-config"])),
+
+        // Databases
+        "pg" => Some((&["postgresql"], &[])),
+        "mysql2" => Some((&["libmysqlclient"], &[])),
+        "sqlite3" => Some((&["sqlite"], &[])),
+
+        // Redis
+        "redis" => Some((&[], &[])), // Pure Ruby, no native deps
+
+        // HTTP/SSL
+        "eventmachine" => Some((&["openssl"], &[])),
+        "puma" => Some((&["openssl"], &[])),
+
+        // Compression
+        "bzip2-ffi" | "bzip2-ruby" => Some((&["bzip2"], &[])),
+
+        // Image processing
+        "rmagick" => Some((&["imagemagick"], &["pkg-config"])),
+        "mini_magick" => Some((&["imagemagick"], &[])),
+
+        // System libraries
+        "ffi" => Some((&[], &[])), // libffi is usually available by default
+        "curses" => Some((&["ncurses"], &[])),
+
+        // JSON (native extensions for performance)
+        "json" | "oj" => Some((&[], &[])), // Pure C, no external deps
+
+        // Build tools
+        "bundler" => Some((&[], &[])), // No native deps
+
+        _ => None,
+    }
+}
+
+/// Parse the given `Gemfile.lock` text and return a deduplicated list of
+/// every gem name in the lockfile.
+///
+/// The Gemfile.lock format we parse looks like:
+///
+/// ```text
+/// GEM
+///   remote: https://rubygems.org/
+///   specs:
+///     nokogiri (1.13.0)
+///       mini_portile2 (~> 2.8.0)
+///     pg (1.3.0)
+/// ```
+///
+/// We extract gem names from the indented lines under `specs:`.
+pub fn parse_gemfile_lock(gemfile_lock: &str) -> Vec<String> {
+    let mut names: BTreeSet<String> = BTreeSet::new();
+    let mut in_specs = false;
+
+    for line in gemfile_lock.lines() {
+        let trimmed = line.trim_start();
+
+        // Look for the "specs:" section
+        if trimmed == "specs:" {
+            in_specs = true;
+            continue;
+        }
+
+        // Exit specs section when we hit a non-indented line (except blank lines)
+        if in_specs && !line.is_empty() && !line.starts_with(' ') {
+            in_specs = false;
+        }
+
+        if in_specs && line.starts_with("    ") {
+            // Lines with exactly 4 spaces are gem declarations
+            // Format: "    gem_name (version)" or "    gem_name"
+            let gem_line = line.trim();
+            if let Some(name_end) = gem_line.find(|c: char| c == ' ' || c == '(') {
+                let gem_name = &gem_line[..name_end];
+                if !gem_name.is_empty() {
+                    names.insert(gem_name.to_owned());
+                }
+            }
+        }
+    }
+
+    names.into_iter().collect()
+}
+
+/// Given an `ExpressionInfo` with a Ruby template, attempt to infer system
+/// dependencies by reading the project's `Gemfile.lock` and mapping known
+/// gems to their nixpkgs equivalents.
+///
+/// Returns `true` if we successfully found and parsed a lockfile; `false`
+/// otherwise. Even when returning `true`, the inferred lists may be empty
+/// if no mappable gems were found.
+pub fn infer_dependencies(info: &mut ExpressionInfo) -> bool {
+    let gemfile_lock_path = info.top_level_path.join("Gemfile.lock");
+
+    if !gemfile_lock_path.exists() {
+        debug!(
+            target: LOG_TARGET,
+            "No Gemfile.lock at {:?}; skipping dependency inference",
+            gemfile_lock_path
+        );
+        return false;
+    }
+
+    let lockfile_content = match std::fs::read_to_string(&gemfile_lock_path) {
+        Ok(s) => s,
+        Err(e) => {
+            debug!(
+                target: LOG_TARGET,
+                "Failed to read {:?}: {}; skipping dependency inference",
+                gemfile_lock_path,
+                e
+            );
+            return false;
+        }
+    };
+
+    let gems = parse_gemfile_lock(&lockfile_content);
+    debug!(
+        target: LOG_TARGET,
+        "Parsed {} gems from Gemfile.lock",
+        gems.len()
+    );
+
+    let mut build_inputs: BTreeSet<String> = BTreeSet::new();
+    let mut native_build_inputs: BTreeSet<String> = BTreeSet::new();
+
+    for gem in &gems {
+        if let Some((bi, nbi)) = lookup_gem(gem) {
+            debug!(target: LOG_TARGET, "Mapped gem '{}' to buildInputs={:?}, nativeBuildInputs={:?}", gem, bi, nbi);
+            build_inputs.extend(bi.iter().map(|s| s.to_string()));
+            native_build_inputs.extend(nbi.iter().map(|s| s.to_string()));
+        }
+    }
+
+    info.build_inputs.extend(build_inputs);
+    info.native_build_inputs.extend(native_build_inputs);
+
+    debug!(
+        target: LOG_TARGET,
+        "Inferred buildInputs={:?}, nativeBuildInputs={:?}",
+        info.build_inputs,
+        info.native_build_inputs
+    );
+
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_basic_gemfile_lock() {
+        let lockfile = r#"GEM
+  remote: https://rubygems.org/
+  specs:
+    nokogiri (1.13.0)
+      mini_portile2 (~> 2.8.0)
+    pg (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  nokogiri
+  pg
+"#;
+        let gems = parse_gemfile_lock(lockfile);
+        assert_eq!(gems, vec!["mini_portile2", "nokogiri", "pg"]);
+    }
+
+    #[test]
+    fn parse_handles_empty_or_malformed() {
+        assert_eq!(parse_gemfile_lock(""), Vec::<String>::new());
+        assert_eq!(parse_gemfile_lock("random text"), Vec::<String>::new());
+    }
+
+    #[test]
+    fn lookup_nokogiri() {
+        let result = lookup_gem("nokogiri");
+        assert_eq!(
+            result,
+            Some((
+                &["libxml2", "libxslt"] as &[&str],
+                &["pkg-config"] as &[&str]
+            ))
+        );
+    }
+
+    #[test]
+    fn lookup_pg() {
+        let result = lookup_gem("pg");
+        assert_eq!(result, Some((&["postgresql"] as &[&str], &[] as &[&str])));
+    }
+
+    #[test]
+    fn lookup_unknown_gem() {
+        assert_eq!(lookup_gem("unknown-gem-12345"), None);
+    }
+
+    #[test]
+    fn infer_from_lockfile_with_known_gems() {
+        use crate::types::{ExpressionInfo, Fetcher, Template};
+        use std::path::PathBuf;
+
+        // Create a temporary directory with a Gemfile.lock
+        let temp_dir = std::env::temp_dir().join("nix-template-ruby-test");
+        std::fs::create_dir_all(&temp_dir).unwrap();
+        let lockfile_path = temp_dir.join("Gemfile.lock");
+        std::fs::write(
+            &lockfile_path,
+            r#"GEM
+  remote: https://rubygems.org/
+  specs:
+    nokogiri (1.13.0)
+    pg (1.3.0)
+"#,
+        )
+        .unwrap();
+
+        let mut info = ExpressionInfo {
+            pname: "test".to_owned(),
+            version: "1.0.0".to_owned(),
+            license: "mit".to_owned(),
+            maintainer: "me".to_owned(),
+            fetcher: Fetcher::github,
+            template: Template::ruby,
+            path_to_write: PathBuf::new(),
+            top_level_path: temp_dir.clone(),
+            include_documentation_links: false,
+            include_meta: true,
+            tag_prefix: "".to_owned(),
+            owner: "test".to_owned(),
+            src_sha: "sha256-test".to_owned(),
+            description: "test".to_owned(),
+            homepage: "https://example.com".to_owned(),
+            propagated_build_inputs: Vec::new(),
+            cargo_hash: "".to_owned(),
+            vendor_hash: "".to_owned(),
+            npm_deps_hash: "".to_owned(),
+            pnpm_deps_hash: "".to_owned(),
+            project_file: "".to_owned(),
+            domain: "".to_owned(),
+            build_inputs: Vec::new(),
+            native_build_inputs: Vec::new(),
+        };
+
+        let success = infer_dependencies(&mut info);
+        assert!(success);
+
+        // Should have inferred deps from nokogiri and pg
+        let mut expected_build = vec!["libxml2", "libxslt", "postgresql"];
+        expected_build.sort();
+        let mut actual_build = info.build_inputs.clone();
+        actual_build.sort();
+        assert_eq!(actual_build, expected_build);
+
+        let expected_native = vec!["pkg-config"];
+        assert_eq!(info.native_build_inputs, expected_native);
+
+        // Cleanup
+        std::fs::remove_dir_all(&temp_dir).ok();
+    }
+}
diff --git a/src/types/mod.rs b/src/types/mod.rs
index 6524f64..d64e9a4 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -91,6 +91,8 @@ arg_enum! {
         rust,
         npm,
         pnpm,
+        dotnet,
+        ruby,
         test,
     }
 }
@@ -175,6 +177,9 @@ pub struct ExpressionInfo {
     /// SRI hash of the pnpm dependencies (used for `pnpm` template).
     /// Defaults to `lib.fakeHash` when unknown.
     pub pnpm_deps_hash: String,
+    /// Path to the .NET project file (used for `dotnet` template).
+    /// Typically a .csproj, .fsproj, or .sln file relative to src root.
+    pub project_file: String,
     /// Domain of the Gitea instance (used by the `gitea` fetcher), e.g.
     /// "codeberg.org" or "gitea.com". Empty for non-Gitea fetchers.
     pub domain: String,
@@ -218,6 +223,7 @@ impl ExpressionInfo {
             .replace("@vendor_hash@", &self.vendor_hash)
             .replace("@npm_deps_hash@", &self.npm_deps_hash)
             .replace("@pnpm_deps_hash@", &self.pnpm_deps_hash)
+            .replace("@project_file@", &self.project_file)
             .replace("@domain@", &self.domain)
             .replace("@description@", &self.description)
             .replace("@homepage@", &self.homepage)
diff --git a/src/url.rs b/src/url.rs
index 28ebde4..2d9af68 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -928,6 +928,7 @@ pub fn prefetch_dependency_hash(info: &types::ExpressionInfo) -> Option<String>
         vendor_hash: FAKE_SRI_HASH.to_owned(),
         npm_deps_hash: FAKE_SRI_HASH.to_owned(),
         pnpm_deps_hash: FAKE_SRI_HASH.to_owned(),
+        project_file: String::new(),
         domain: info.domain.clone(),
         // Probe expressions don't need to render the inferred deps;
         // we want a minimal expression that just exercises src + cargo.
@@ -1025,6 +1026,71 @@ fn tempfile_dir() -> Option<std::path::PathBuf> {
     Some(dir)
 }
 
+/// Infer the .NET project file path by materializing the source and scanning for
+/// .csproj, .fsproj, or .sln files. Returns the path relative to the source root,
+/// or None if no project file is found or the source cannot be materialized.
+pub fn infer_dotnet_project_file(info: &types::ExpressionInfo) -> Option<String> {
+    use std::path::Path;
+
+    eprintln!("Materialising source to detect .NET project file...");
+    let source_path = match crate::source::materialise_source(info) {
+        Some(p) => p,
+        None => {
+            debug!(target: LOG_TARGET, "failed to materialise source; cannot infer project file");
+            return None;
+        }
+    };
+
+    // Search for project files in order of preference:
+    // 1. .csproj files (C#)
+    // 2. .fsproj files (F#)
+    // 3. .sln files (Solution)
+
+    fn find_project_files(dir: &Path, extension: &str) -> Vec<std::path::PathBuf> {
+        use std::fs;
+
+        let mut results = Vec::new();
+        if let Ok(entries) = fs::read_dir(dir) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some(extension) {
+                    results.push(path);
+                } else if path.is_dir() {
+                    // Recursively search subdirectories (up to 3 levels deep)
+                    results.extend(find_project_files(&path, extension));
+                }
+            }
+        }
+        results
+    }
+
+    // Try .csproj first
+    let mut candidates = find_project_files(&source_path, "csproj");
+    if candidates.is_empty() {
+        // Try .fsproj
+        candidates = find_project_files(&source_path, "fsproj");
+    }
+    if candidates.is_empty() {
+        // Try .sln
+        candidates = find_project_files(&source_path, "sln");
+    }
+
+    if candidates.is_empty() {
+        eprintln!("No .NET project files (.csproj, .fsproj, .sln) found in source");
+        return None;
+    }
+
+    // Prefer files in the root directory, then shortest path
+    candidates.sort_by_key(|p| p.components().count());
+
+    let chosen = &candidates[0];
+    let relative = chosen.strip_prefix(&source_path).ok()?;
+    let relative_str = relative.to_str()?;
+
+    eprintln!("Detected project file: {}", relative_str);
+    Some(relative_str.to_owned())
+}
+
 pub fn read_meta_from_url(url: &str, info: &mut types::ExpressionInfo, include_prereleases: bool) {
     let trimmed_url = url
         .trim_start_matches("http://")
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
index ce50e96..b5ce3a1 100644
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -1,4 +1,5 @@
 use assert_cmd::Command;
+use std::fs;
 use tempfile::TempDir;
 
 /// Test basic Python template generation without --flake-init
@@ -583,3 +584,150 @@ fn test_pnpm_template_basic() {
     // Snapshot the output
     insta::assert_snapshot!("pnpm_basic_template", stdout);
 }
+
+#[test]
+fn test_dotnet_template_basic() {
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path().join("default.nix");
+
+    let output = Command::cargo_bin("nix-template").unwrap()
+        .args(&[
+            "dotnet",
+            "--pname",
+            "example",
+            "--maintainer",
+            "me",
+            temp_path.to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(
+        output.status.success(),
+        "Command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Read the generated file
+    let stdout = fs::read_to_string(&temp_path).expect("Failed to read output file");
+
+    // Verify it contains buildDotnetModule with finalAttrs pattern
+    assert!(stdout.contains("buildDotnetModule"));
+    assert!(stdout.contains("buildDotnetModule (finalAttrs: {"));
+    assert!(stdout.contains("projectFile = \"CHANGE\";"));
+    assert!(stdout.contains("nugetDeps = ./deps.json;"));
+    assert!(stdout.contains("finalAttrs.pname"));
+    assert!(stdout.contains("finalAttrs.version"));
+
+    // Verify proper spacing (blank lines between sections)
+    assert!(stdout.contains("version = \"0.0.1\";\n\n  src ="));
+    assert!(stdout.contains("  };\n\n  projectFile ="));
+    assert!(stdout.contains("  nugetDeps = ./deps.json;  # Run `nix-build -A package-name.passthru.fetch-deps` to generate\n\n  meta ="));
+
+    // Snapshot the output
+    insta::assert_snapshot!("dotnet_basic_template", stdout);
+}
+
+#[test]
+fn test_ruby_template_basic() {
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path().join("default.nix");
+
+    let output = Command::cargo_bin("nix-template").unwrap()
+        .args(&[
+            "ruby",
+            "--pname",
+            "example",
+            "--maintainer",
+            "me",
+            temp_path.to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(
+        output.status.success(),
+        "Command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Read the generated file
+    let stdout = fs::read_to_string(&temp_path).expect("Failed to read output file");
+
+    // Verify it contains bundlerApp (NOT finalAttrs pattern)
+    assert!(stdout.contains("bundlerApp"));
+    assert!(stdout.contains("bundlerApp {"));
+    assert!(!stdout.contains("finalAttrs"));  // Ruby doesn't use finalAttrs
+    assert!(stdout.contains("gemdir = ./.;"));
+    assert!(stdout.contains("exes = [ \"example\" ];"));
+
+    // Verify function header
+    assert!(stdout.contains("{ lib\n, bundlerApp"));
+
+    // Verify proper spacing (blank lines between sections)
+    assert!(stdout.contains("pname = \"example\";\n  gemdir"));
+
+    // Snapshot the output
+    insta::assert_snapshot!("ruby_basic_template", stdout);
+}
+
+#[test]
+fn test_ruby_template_with_dependency_inference() {
+    let temp_dir = TempDir::new().unwrap();
+
+    // Create a Gemfile.lock with known gems that have native dependencies
+    let gemfile_lock = temp_dir.path().join("Gemfile.lock");
+    fs::write(
+        &gemfile_lock,
+        r#"GEM
+  remote: https://rubygems.org/
+  specs:
+    nokogiri (1.13.10)
+      mini_portile2 (~> 2.8.0)
+    pg (1.4.5)
+    mini_portile2 (2.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  nokogiri
+  pg
+
+BUNDLED WITH
+   2.3.0
+"#,
+    )
+    .unwrap();
+
+    let output_path = temp_dir.path().join("default.nix");
+
+    let output = Command::cargo_bin("nix-template").unwrap()
+        .current_dir(temp_dir.path())
+        .args(&[
+            "ruby",
+            "--pname",
+            "example",
+            "--maintainer",
+            "me",
+            output_path.to_str().unwrap(),
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    assert!(
+        output.status.success(),
+        "Command failed: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+
+    // Read the generated file
+    let content = fs::read_to_string(&output_path).expect("Failed to read output file");
+
+    // Without --from-url, dependencies should NOT be inferred
+    // (inference only happens with --from-url flag)
+    assert!(!content.contains("buildInputs"));
+    assert!(!content.contains("nativeBuildInputs"));
+    assert!(!content.contains("libxml2"));
+    assert!(!content.contains("postgresql"));
+}
diff --git a/tests/snapshots/integration_tests__dotnet_basic_template.snap b/tests/snapshots/integration_tests__dotnet_basic_template.snap
new file mode 100644
index 0000000..02454b9
--- /dev/null
+++ b/tests/snapshots/integration_tests__dotnet_basic_template.snap
@@ -0,0 +1,30 @@
+---
+source: tests/integration_tests.rs
+expression: stdout
+---
+{ lib
+, buildDotnetModule
+, fetchFromGitHub
+}:
+
+buildDotnetModule (finalAttrs: {
+  pname = "example";
+  version = "0.0.1";
+
+  src = fetchFromGitHub {
+    owner = "CHANGE";
+    repo = finalAttrs.pname;
+    rev = finalAttrs.version;
+    sha256 = "0000000000000000000000000000000000000000000000000000";
+  };
+
+  projectFile = "CHANGE";
+  nugetDeps = ./deps.json;  # Run `nix-build -A package-name.passthru.fetch-deps` to generate
+
+  meta = with lib; {
+    description = "CHANGE";
+    homepage = "https://github.com/CHANGE/example";
+    license = licenses.CHANGE;
+    maintainers = with maintainers; [ me ];
+  };
+})
diff --git a/tests/snapshots/integration_tests__ruby_basic_template.snap b/tests/snapshots/integration_tests__ruby_basic_template.snap
new file mode 100644
index 0000000..3f950e6
--- /dev/null
+++ b/tests/snapshots/integration_tests__ruby_basic_template.snap
@@ -0,0 +1,20 @@
+---
+source: tests/integration_tests.rs
+expression: stdout
+---
+{ lib
+, bundlerApp
+}:
+
+bundlerApp {
+  pname = "example";
+  gemdir = ./.;
+  exes = [ "example" ];  # To build this package, you need Gemfile, Gemfile.lock, and gemset.nix in this directory
+
+  meta = with lib; {
+    description = "CHANGE";
+    homepage = "https://github.com/CHANGE/example";
+    license = licenses.CHANGE;
+    maintainers = with maintainers; [ me ];
+  };
+}