cuda-rust-wasm 0.1.7

CUDA to Rust transpiler with WebGPU/WASM support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use clap::{Parser, Subcommand};
use cuda_rust_wasm::transpiler::CudaTranspiler;
use std::fs;
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "cuda2rust")]
#[command(about = "CUDA to Rust/WASM transpiler")]
#[command(version = "0.1.0")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Transpile CUDA code to Rust
    Transpile {
        /// Input CUDA file
        #[arg(short, long)]
        input: PathBuf,
        
        /// Output Rust file
        #[arg(short, long)]
        output: Option<PathBuf>,
        
        /// Enable optimizations
        #[arg(long)]
        optimize: bool,
        
        /// Enable pattern detection
        #[arg(long)]
        detect_patterns: bool,
        
        /// Verbose output
        #[arg(short, long)]
        verbose: bool,
    },
    
    /// Generate WebGPU shader
    GenerateWgsl {
        /// Input CUDA file
        #[arg(short, long)]
        input: PathBuf,
        
        /// Output WGSL file
        #[arg(short, long)]
        output: Option<PathBuf>,
    },
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Transpile { input, output, optimize, detect_patterns, verbose } => {
            if verbose {
                env_logger::init();
            }
            
            let cuda_source = fs::read_to_string(&input)?;
            let transpiler = CudaTranspiler::new();
            
            let rust_code = transpiler.transpile(&cuda_source, optimize, detect_patterns)?;
            
            if let Some(output_path) = output {
                fs::write(&output_path, rust_code)?;
                println!("Transpiled CUDA to Rust: {} -> {}", input.display(), output_path.display());
            } else {
                println!("{rust_code}");
            }
        }
        
        Commands::GenerateWgsl { input, output } => {
            let cuda_source = fs::read_to_string(&input)?;
            let transpiler = CudaTranspiler::new();
            
            let wgsl_code = transpiler.generate_wgsl(&cuda_source)?;
            
            if let Some(output_path) = output {
                fs::write(&output_path, wgsl_code)?;
                println!("Generated WGSL shader: {} -> {}", input.display(), output_path.display());
            } else {
                println!("{wgsl_code}");
            }
        }
    }
    
    Ok(())
}