Add koltin multiplatform client SDK with codegen, gradle plugin and templates

README.md

@@ -168,6 +168,7 @@ Connect from any of these platforms:
 | **TypeScript** (React, Next.js, Vue, Svelte, Angular, Node.js, Bun, Deno) | [Get started](https://spacetimedb.com/docs/quickstarts/react) |
 | **Rust** | [Get started](https://spacetimedb.com/docs/quickstarts/rust) |
 | **C#** (standalone and Unity) | [Get started](https://spacetimedb.com/docs/quickstarts/c-sharp) |
+| **Kotlin** (Android, JVM, iOS/Native) | [Get started](https://spacetimedb.com/docs/quickstarts/kotlin) |
 | **C++** (Unreal Engine) | [Get started](https://spacetimedb.com/docs/quickstarts/c-plus-plus) |
 
 ## Running with Docker

crates/cli/build.rs

@@ -84,21 +84,44 @@ fn generate_template_files() {
         .push_str("pub fn get_template_files() -> HashMap<&'static str, HashMap<&'static str, &'static str>> {\n");
     generated_code.push_str("    let mut templates = HashMap::new();\n\n");
 
+    let mut binary_code = String::new();
+    binary_code.push_str("#[allow(unused_mut)]\n");
+    binary_code.push_str(
+        "pub fn get_template_binary_files() -> HashMap<&'static str, HashMap<&'static str, &'static [u8]>> {\n",
+    );
+    binary_code.push_str("    let mut templates = HashMap::new();\n\n");
+
     for template in &discovered_templates {
         if let Some(ref server_source) = template.server_source {
             let server_path = PathBuf::from(server_source);
-            generate_template_entry(&mut generated_code, &server_path, server_source, &manifest_dir);
+            generate_template_entry(
+                &mut generated_code,
+                &mut binary_code,
+                &server_path,
+                server_source,
+                &manifest_dir,
+            );
         }
 
         if let Some(ref client_source) = template.client_source {
             let client_path = PathBuf::from(client_source);
-            generate_template_entry(&mut generated_code, &client_path, client_source, &manifest_dir);
+            generate_template_entry(
+                &mut generated_code,
+                &mut binary_code,
+                &client_path,
+                client_source,
+                &manifest_dir,
+            );
         }
     }
 
     generated_code.push_str("    templates\n");
     generated_code.push_str("}\n\n");
 
+    binary_code.push_str("    templates\n");
+    binary_code.push_str("}\n\n");
+    generated_code.push_str(&binary_code);
+
     let repo_root = get_repo_root();
     let workspace_cargo = repo_root.join("Cargo.toml");
     println!("cargo:rerun-if-changed={}", workspace_cargo.display());
@@ -297,7 +320,17 @@ where
     serializer.serialize_str(value.as_deref().unwrap_or(""))
 }
 
-fn generate_template_entry(code: &mut String, template_path: &Path, source: &str, manifest_dir: &Path) {
+fn is_binary_file(path: &str) -> bool {
+    path.ends_with(".jar")
+}
+
+fn generate_template_entry(
+    code: &mut String,
+    binary_code: &mut String,
+    template_path: &Path,
+    source: &str,
+    manifest_dir: &Path,
+) {
     let (git_files, resolved_base) = get_git_tracked_files(template_path, manifest_dir);
 
     if git_files.is_empty() {
@@ -334,6 +367,9 @@ fn generate_template_entry(code: &mut String, template_path: &Path, source: &str
     code.push_str("    {\n");
     code.push_str("        let mut files = HashMap::new();\n");
 
+    binary_code.push_str("    {\n");
+    binary_code.push_str("        let mut files = HashMap::new();\n");
+
     for file_path in git_files {
         // Example file_path: modules/chat-console-rs/src/lib.rs (relative to repo root)
         // Example resolved_base: modules/chat-console-rs
@@ -386,15 +422,25 @@ fn generate_template_entry(code: &mut String, template_path: &Path, source: &str
             // Example include_path (inside crate): "templates/basic-rs/server/src/lib.rs"
             // Example include_path (outside crate): ".templates/parent_parent_modules_chat-console-rs/src/lib.rs"
             // Example relative_str: "src/lib.rs"
-            code.push_str(&format!(
-                "        files.insert(\"{}\", include_str!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/{}\")));\n",
-                relative_str, include_path
-            ));
+            if is_binary_file(&relative_str) {
+                binary_code.push_str(&format!(
+                    "        files.insert(\"{}\", include_bytes!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/{}\")).as_slice());\n",
+                    relative_str, include_path
+                ));
+            } else {
+                code.push_str(&format!(
+                    "        files.insert(\"{}\", include_str!(concat!(env!(\"CARGO_MANIFEST_DIR\"), \"/{}\")));\n",
+                    relative_str, include_path
+                ));
+            }
         }
     }
 
     code.push_str(&format!("        templates.insert(\"{}\", files);\n", source));
     code.push_str("    }\n\n");
+
+    binary_code.push_str(&format!("        templates.insert(\"{}\", files);\n", source));
+    binary_code.push_str("    }\n\n");
 }
 
 /// Get a list of files tracked by git from a given directory

crates/cli/src/subcommands/generate.rs

@@ -6,8 +6,8 @@ use clap::Arg;
 use clap::ArgAction::{Set, SetTrue};
 use fs_err as fs;
 use spacetimedb_codegen::{
-    generate, private_table_names, CodegenOptions, CodegenVisibility, Csharp, Lang, OutputFile, Rust, TypeScript,
-    UnrealCpp, AUTO_GENERATED_PREFIX,
+    generate, private_table_names, CodegenOptions, CodegenVisibility, Csharp, Kotlin, Lang, OutputFile, Rust,
+    TypeScript, UnrealCpp, AUTO_GENERATED_PREFIX,
 };
 use spacetimedb_lib::de::serde::DeserializeWrapper;
 use spacetimedb_lib::{sats, RawModuleDef};
@@ -20,6 +20,7 @@ use crate::spacetime_config::{
     find_and_load_with_env, CommandConfig, CommandSchema, CommandSchemaBuilder, Key, LoadedConfig, SpacetimeConfig,
 };
 use crate::tasks::csharp::dotnet_format;
+use crate::tasks::kotlin::ktfmt;
 use crate::tasks::rust::rustfmt;
 use crate::util::{resolve_sibling_binary, y_or_n};
 use crate::Config;
@@ -396,6 +397,9 @@ fn detect_default_language(client_project_dir: &Path) -> anyhow::Result<Language
     if client_project_dir.join("Cargo.toml").exists() {
         return Ok(Language::Rust);
     }
+    if client_project_dir.join("build.gradle.kts").exists() || client_project_dir.join("build.gradle").exists() {
+        return Ok(Language::Kotlin);
+    }
     if let Ok(entries) = fs::read_dir(client_project_dir)
         && entries
             .flatten()
@@ -415,6 +419,7 @@ fn language_cli_name(lang: Language) -> &'static str {
     match lang {
         Language::Rust => "rust",
         Language::Csharp => "csharp",
+        Language::Kotlin => "kotlin",
         Language::TypeScript => "typescript",
         Language::UnrealCpp => "unrealcpp",
     }
@@ -424,6 +429,7 @@ pub fn default_out_dir_for_language(lang: Language) -> Option<PathBuf> {
     match lang {
         Language::Rust | Language::TypeScript => Some(PathBuf::from("src/module_bindings")),
         Language::Csharp => Some(PathBuf::from("module_bindings")),
+        Language::Kotlin => Some(PathBuf::from("module_bindings")),
         Language::UnrealCpp => None,
     }
 }
@@ -516,6 +522,7 @@ pub async fn run_prepared_generate_configs(
                 };
                 &csharp_lang as &dyn Lang
             }
+            Language::Kotlin => &Kotlin,
             Language::UnrealCpp => {
                 unreal_cpp_lang = UnrealCpp {
                     module_name: run.module_name.as_ref().unwrap(),
@@ -684,6 +691,7 @@ pub async fn exec_from_entries(
 #[serde(rename_all = "lowercase")]
 pub enum Language {
     Csharp,
+    Kotlin,
     TypeScript,
     Rust,
     #[serde(alias = "uecpp", alias = "ue5cpp", alias = "unreal")]
@@ -692,11 +700,18 @@ pub enum Language {
 
 impl clap::ValueEnum for Language {
     fn value_variants<'a>() -> &'a [Self] {
-        &[Self::Csharp, Self::TypeScript, Self::Rust, Self::UnrealCpp]
+        &[
+            Self::Csharp,
+            Self::Kotlin,
+            Self::TypeScript,
+            Self::Rust,
+            Self::UnrealCpp,
+        ]
     }
     fn to_possible_value(&self) -> Option<PossibleValue> {
         Some(match self {
             Self::Csharp => clap::builder::PossibleValue::new("csharp").aliases(["c#", "cs"]),
+            Self::Kotlin => clap::builder::PossibleValue::new("kotlin").aliases(["kt", "KT"]),
             Self::TypeScript => clap::builder::PossibleValue::new("typescript").aliases(["ts", "TS"]),
             Self::Rust => clap::builder::PossibleValue::new("rust").aliases(["rs", "RS"]),
             Self::UnrealCpp => PossibleValue::new("unrealcpp").aliases(["uecpp", "ue5cpp", "unreal"]),
@@ -710,6 +725,7 @@ impl Language {
         match self {
             Language::Rust => "Rust",
             Language::Csharp => "C#",
+            Language::Kotlin => "Kotlin",
             Language::TypeScript => "TypeScript",
             Language::UnrealCpp => "Unreal C++",
         }
@@ -719,6 +735,7 @@ impl Language {
         match self {
             Language::Rust => rustfmt(generated_files)?,
             Language::Csharp => dotnet_format(project_dir, generated_files)?,
+            Language::Kotlin => ktfmt(generated_files)?,
             Language::TypeScript => {
                 // TODO: implement formatting.
             }

crates/cli/src/subcommands/init.rs

@@ -86,6 +86,7 @@ pub enum ClientLanguage {
     Rust,
     Csharp,
     TypeScript,
+    Kotlin,
 }
 
 impl ClientLanguage {
@@ -94,6 +95,7 @@ impl ClientLanguage {
             ClientLanguage::Rust => "rust",
             ClientLanguage::Csharp => "csharp",
             ClientLanguage::TypeScript => "typescript",
+            ClientLanguage::Kotlin => "kotlin",
         }
     }
 
@@ -102,6 +104,7 @@ impl ClientLanguage {
             "rust" => Ok(Some(ClientLanguage::Rust)),
             "csharp" | "c#" => Ok(Some(ClientLanguage::Csharp)),
             "typescript" => Ok(Some(ClientLanguage::TypeScript)),
+            "kotlin" | "kt" => Ok(Some(ClientLanguage::Kotlin)),
             _ => Err(anyhow!("Unknown client language: {}", s)),
         }
     }
@@ -1119,6 +1122,32 @@ pub fn update_csproj_client_to_nuget(dir: &Path) -> anyhow::Result<()> {
     Ok(())
 }
 
+/// Sets up a Kotlin client project: updates the project name and makes gradlew executable.
+fn setup_kotlin_client(dir: &Path, project_name: &str) -> anyhow::Result<()> {
+    let settings_path = dir.join("settings.gradle.kts");
+    if settings_path.exists() {
+        let original = fs::read_to_string(&settings_path)?;
+        let re = regex::Regex::new(r#"rootProject\.name\s*=\s*"[^"]*""#).unwrap();
+        let updated = re
+            .replace(&original, &format!("rootProject.name = \"{}\"", project_name))
+            .to_string();
+        if updated != original {
+            fs::write(&settings_path, updated)?;
+        }
+    }
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let gradlew = dir.join("gradlew");
+        if gradlew.exists() {
+            fs::set_permissions(&gradlew, fs::Permissions::from_mode(0o755))?;
+        }
+    }
+
+    Ok(())
+}
+
 // Helpers
 
 fn write_if_changed(path: PathBuf, original: String, root: Element) -> anyhow::Result<()> {
@@ -1324,6 +1353,7 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
         .ok_or_else(|| anyhow::anyhow!("Template definition missing"))?;
 
     let template_files = embedded::get_template_files();
+    let template_binary_files = embedded::get_template_binary_files();
 
     if !is_server_only {
         println!(
@@ -1332,7 +1362,7 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
         );
         let client_source = &template_def.client_source;
         if let Some(files) = template_files.get(client_source.as_str()) {
-            copy_embedded_files(files, project_path)?;
+            copy_embedded_files(files, template_binary_files.get(client_source.as_str()), project_path)?;
         } else {
             anyhow::bail!("Client template not found: {}", client_source);
         }
@@ -1353,6 +1383,9 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
             Some(ClientLanguage::Csharp) => {
                 update_csproj_client_to_nuget(project_path)?;
             }
+            Some(ClientLanguage::Kotlin) => {
+                setup_kotlin_client(project_path, &config.project_name)?;
+            }
             None => {}
         }
     }
@@ -1364,7 +1397,7 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
     let server_dir = project_path.join("spacetimedb");
     let server_source = &template_def.server_source;
     if let Some(files) = template_files.get(server_source.as_str()) {
-        copy_embedded_files(files, &server_dir)?;
+        copy_embedded_files(files, template_binary_files.get(server_source.as_str()), &server_dir)?;
     } else {
         anyhow::bail!("Server template not found: {}", server_source);
     }
@@ -1389,7 +1422,11 @@ fn init_builtin(config: &TemplateConfig, project_path: &Path, is_server_only: bo
     Ok(())
 }
 
-fn copy_embedded_files(files: &HashMap<&str, &str>, target_dir: &Path) -> anyhow::Result<()> {
+fn copy_embedded_files(
+    files: &HashMap<&str, &str>,
+    binary_files: Option<&HashMap<&str, &[u8]>>,
+    target_dir: &Path,
+) -> anyhow::Result<()> {
     for (file_path, content) in files {
         // Skip .template.json files - they're only for template metadata
         if file_path.ends_with(".template.json") {
@@ -1402,6 +1439,15 @@ fn copy_embedded_files(files: &HashMap<&str, &str>, target_dir: &Path) -> anyhow
         }
         fs::write(&full_path, content)?;
     }
+    if let Some(binaries) = binary_files {
+        for (file_path, content) in binaries {
+            let full_path = target_dir.join(file_path);
+            if let Some(parent) = full_path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            fs::write(&full_path, content)?;
+        }
+    }
     Ok(())
 }
 
@@ -1512,6 +1558,14 @@ fn print_next_steps(config: &TemplateConfig, _project_path: &Path) -> anyhow::Re
             );
             println!("  spacetime generate --lang csharp --out-dir module_bindings --module-path spacetimedb");
         }
+        (TemplateType::Builtin, Some(ServerLanguage::Rust), Some(ClientLanguage::Kotlin)) => {
+            println!(
+                "  spacetime publish --module-path spacetimedb {}{}",
+                if config.use_local { "--server local " } else { "" },
+                config.project_name
+            );
+            println!("  ./gradlew run");
+        }
         (TemplateType::Empty, _, Some(ClientLanguage::TypeScript)) => {
             println!("  npm install");
             if config.server_lang.is_some() {

crates/cli/src/tasks/kotlin.rs

@@ -0,0 +1,31 @@
+use std::ffi::OsString;
+use std::path::PathBuf;
+
+use anyhow::Context;
+use itertools::Itertools;
+
+fn has_ktfmt() -> bool {
+    duct::cmd!("ktfmt", "--version")
+        .stdout_null()
+        .stderr_null()
+        .run()
+        .is_ok()
+}
+
+pub(crate) fn ktfmt(files: impl IntoIterator<Item = PathBuf>) -> anyhow::Result<()> {
+    if !has_ktfmt() {
+        eprintln!("ktfmt not found — skipping Kotlin formatting.");
+        eprintln!("Install ktfmt from https://github.com/facebook/ktfmt to auto-format generated code.");
+        return Ok(());
+    }
+    duct::cmd(
+        "ktfmt",
+        itertools::chain(
+            ["--kotlinlang-style"].into_iter().map_into::<OsString>(),
+            files.into_iter().map_into(),
+        ),
+    )
+    .run()
+    .context("ktfmt failed")?;
+    Ok(())
+}

crates/cli/src/tasks/mod.rs

@@ -60,4 +60,5 @@ pub fn build(
 pub mod cpp;
 pub mod csharp;
 pub mod javascript;
+pub mod kotlin;
 pub mod rust;