For developers
Codcel transpiles a spreadsheet into real source code in your language — readable, version-controlled, test-covered, and deployable in your own CI/CD. No runtime to adopt, no vendor lock-in, no black box.
Your model in Excel

Generated code, in seconds
use std::error::Error;
#[derive(Debug, Clone)]
pub struct StressTestInput {
pub balance: f64,
pub pd: f64,
pub lgd: f64,
pub pd_shock: f64,
pub lgd_shock: f64,
}
#[derive(Debug, Clone)]
pub struct StressTestOutput {
pub expected_loss: f64,
pub capital_required: f64,
}
fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
let input = StressTestInput {
balance: 1_000_000.0,
pd: 0.02,
lgd: 0.45,
pd_shock: 1.5,
lgd_shock: 1.2,
};
let output = codcel_stress_test(&input)?;
println!("expected_loss: {}", output.expected_loss);
println!("capital_required: {}", output.capital_required);
Ok(())
}Every factor table, every lookup, every formula — translated into type-safe code your IT team reviews, tests against your current outputs, and deploys behind your existing API gateway.
Not config or a DSL. Codcel emits clean Rust, Java, Python, C#, Go, TypeScript and more — the code you'd write by hand, only generated.
Inputs, outputs, and intermediate values are strongly typed. Mismatches fail at compile time, not in production.
Generated code lives in your repos under your license. No proprietary runtime, no per-call fees, no lock-in.
Every project ships with generated tests that benchmark output against the original workbook — including Excel's edge cases.
Plain source you build, test, and deploy with the pipeline and security posture you already run.
The same inputs always produce the same outputs, and every calculation traces back to a cell in the source workbook.
From a single Excel file, Codcel produces full systems — APIs, UIs, libraries, databases, and even MCP servers for AI agents. No templates, no frameworks, no lock-in.
A fully documented REST API built from your Excel logic. Deterministic, type-safe, and ready to deploy to any cloud or on-prem environment.
Generate idiomatic libraries in Rust, Python, Java, C#, Go, Swift, TypeScript and more — readable, testable, and production-ready.
Turn your Excel tables into SQL schemas and high-speed and CSV import for massive datasets (including 1B+ rows).
A complete React-based UI with forms, validation, tables, and live calculation logic connected to your generated backend.
Expose your Excel logic as AI tools. Let ChatGPT or your internal LLM safely call calculations, run scenarios, generate reports, and quote premiums.
Export your Excel logic as a fast, portable WebAssembly module — perfect for embedding directly into browsers, desktop clients, or edge environments.
All generated artifacts are real, human-readable source code — fully owned by you, versioned in your repos, deployed in your architecture, and governed by your processes.
Codcel generates real, production-ready source code across today's most widely used programming languages and ecosystems — with more coming soon.
Rust
Lib · API · WASM · Web
Java
Lib · API · Web
Kotlin
Lib · API · Web (incl. Android)
.NET (C# / VB)
Lib · API · Web
Python
Lib · Web
Go
Lib · API · Web
JavaScript
Web Clients
TypeScript
Web Clients
Swift
Lib · Apple
FFI / C
Native Bindings
AI · MCP
Agent Tools
WASM
WebAssembly Modules
We're continuously expanding Codcel's language and platform support.
Model in Excel.
Domain experts tag inputs and outputs with small inline markers. Existing formulas untouched.
Generate and review.
Codcel emits idiomatic code your engineers review, test, and commit to Git.
Deploy like any service.
Your existing CI/CD, observability, and security posture apply. No new runtime, no new vendor.
Generate your first project in your language in minutes.
Start buildingWatch Excel become a REST API, a web UI, and an MCP server.
Watch demosInspect the calculation, table, and storage engines on GitHub.
Explore the codeOpen-core engines, real source output, no proprietary runtime.
How it worksFree for non-commercial use. Bring a workbook and see the generated project.