Programming language + compiler toolchain

Readable source.Native Rust binaries.

Incan is a statically typed language for clear application code that ships as native Rust binaries. You keep the intent readable; the compiler handles ownership, diagnostics, and the build path.

Try Incan GitHub Read the Docs Duckborrowing →

WriteReadable typed source

PlanOwnership without ceremony

EmitInspectable Rust

Verifyrustc checks the handoff

ShipNative binary

Readable source in. Native binaries out.

Typed by defaultTypes, errors, and mutability stay explicit.

Ownership plannedCompiler-assisted ownership, not runtime guesswork.

Rust emittedGenerated Rust stays inspectable.

Cargo checkedCargo and rustc keep the build honest.

Native binaryNo Python process model at deploy time.

Incan vs Rust, side by side.

Same intent, same output. The Incan side stays Python-shaped and typed; Rust remains the artifact you can inspect when ownership and native deployment matter.

Clear models No borrow ceremony Inspectable artifact Native path

Incan source

model User:
    name: str
    age: int

def greet_user(user: User) -> str:
    return f"Hello, {user.name}!"

def main() -> None:
    user = User(name="Incan", age=42)
    println(greet_user(user))

Comparable Rust

#[derive(Debug, Clone)]
struct User {
    name: String,
    age: i64,
}

fn greet_user(user: &User) -> String {
    format!("Hello, {}!", user.name)
}

fn main() {
    let user = User {
        name: "Incan".to_string(),
        age: 42,
    };
    println!("{}", greet_user(&user));
}

Readable enough for humans. Strict enough for compilers.

Why Incan?

Readable application code without Python's runtime model.

Native artifacts without hand-writing every ownership path.

A smaller surface for application intent, close to Rust semantics.

Generated Rust, diagnostics, and build reports stay inspectable.

Cargo crates and Rust tooling remain in the deployment path.

Duckborrowing plans the handoff from clear source to Rust ownership. Learn more

You write intent.Incan writes ownership.

AI makes syntax cheaper. Toolchains matter more.

When source text is cheap, trust moves to the toolchain. Correctness, diagnostics, inspectability, and deployment matter more than syntax.

Incan is built for that shift: a smaller typed language surface with Rust-native artifacts.

What matters most

• Intent: models, errors, and mutability stay explicit.
• Diagnostics: stable checks, explanations, and inspection data.
• Inspectability: generated Rust and build reports.
• Deployment: native binaries instead of a Python runtime.

Duckborrowing in a nutshell.

Incan plans the Rust-facing ownership path. You keep writing clear application code.

Python-shaped source

Ownership planning

Borrow

Move

Clone

Convert

Owned storage

Generated Rust

Read the Duckborrowing deep dive

Try Incan. Break it. Help shape it.

Incan is beta software. Run it, inspect the generated artifacts, and compare it with Python and Rust on real application code. The project earns trust through feedback.

Try Incan GitHub Read the Docs Duckborrowing →