A native language for reliable systems
Native code.
Typed failure.
Direct style.
Khora is a statically typed, native-compiled language that makes failures, capabilities, resource lifetimes, and concurrency visible without turning application code into ceremony.
It is for people writing services and tools that have to keep running: the kind of program where a dropped error, an unlogged dependency or a leaked handle is found in production rather than in review. Khora puts those four things in the type of a function so they are answered while the code is being written.
pub fn load_user(id: Id) -> User
with { db: Db }
raises DbErrorBefore you read the implementation, the function type already tells you two important things:
The language should tell the truth
A Khora function can make required capabilities and recoverable failures explicit in its type. The same principle extends to concurrency, resources, and memory: important behavior should be visible rather than hidden in convention.
The important parts of a program belong in its model.
Capabilities, not hidden globals
External authority appears in with rows, so dependencies are reviewable without manually passing service objects everywhere.
Typed failure without wrapper types
Recoverable errors live in raises rows while the code stays direct. Handle what you mean to handle and propagate the rest.
Structured concurrency by default
Fibers live inside lexical scopes, so cancellation, joining, and cleanup are part of the concurrency model rather than conventions.
Concurrency →04Native without ownership ceremony
Khora derives memory-management decisions from ordinary functional code instead of asking application developers to write ownership proofs.
Memory model →Direct style, functional core
Functional ideas without a monadic surface.
Khora keeps algebraic data types, immutable values, typed effects, row polymorphism, and composable pipelines while presenting them in code that reads like ordinary application logic.
Learn the language →orders|>List::map(normalize)List::filter(is_valid)List::map(price)One toolchain
The compiler stays the source of truth.
The commands you use every day and the integrations your editor or coding agent starts all talk to the same Khora compiler.
khora checkkhora buildkhora testkhora fmtkhora dockhora lspYour editor starts the language server.khora mcpYour coding agent starts the compiler-backed MCP server.Where next?
Choose the path based on what you want to do, rather than where a page happens to live in the documentation tree.
Go from first program to exact answers.
Start with the language