A functional language that combines
static safety with dynamic flexibility

Hindley-Milner type inference means you write less code while getting more safety. Types are inferred automatically, catching errors at compile time.

# No type annotations needed
add-five = fn(x) => x + 5
result = map add-five [1, 2, 3]
# => [6, 7, 8]

Track side effects at the type level. Know exactly what your functions do—pure computation, I/O, network calls, or state mutations.

# Effects tracked automatically
pure-fn = fn(x) => x * 2
# Effect: Pure

io-fn = fn(msg) => println msg
# Effect: IO

Compile to optimized native binaries via Zig or run directly with the interpreter. Get the performance of native code with zero runtime dependencies.

# Compile to native binary
$ kit build hello.kit -o hello
$ ./hello
Hello, World!

# Or run with interpreter
$ kit run hello.kit

Algebraic data types with powerful pattern matching. Exhaustiveness checking ensures you handle all cases.

type Status = Active | Pending | Closed

message = fn(status) =>
  match status
  | Active -> "Ready to go"
  | Pending -> "Waiting..."
  | Closed -> "Done"

Built-in actors with lock-free mailboxes, work-stealing scheduler, and Erlang-style supervisors. Distributed actors communicate transparently across nodes.

# Create actor with handler and state
handler = fn(msg, state) =>
  match msg
    | :inc -> state + 1
    | :dec -> state - 1

counter = Actor.new handler 0
counter <- :inc  # send message

Built entirely in Zig for fast compilation and small binaries. The compiler generates optimized Zig code that compiles to native executables.

# Two backends, same semantics
$ kit run app.kit  # interpreter
$ kit build app.kit -o app  # compiler

# Both produce identical output
Hello from Kit!

Complete developer toolchain: project initialization, type checking, test runner, package management, and Rust-quality error messages with "Did you mean?" suggestions.

# Complete tooling suite
$ kit init my-project
$ kit check src/main.kit
$ kit test src/tests.kit
$ kit run src/main.kit
# Error: Unbound variable 'greeet'
# Did you mean 'greet'?

Many built-in collections: Map, Set, Deque, Stack, Queue, Heap, Trie, SkipList, Graph, BloomFilter, Rope, AVL/RB/B-Trees, and more. Immutable by default.

# Rich collection library
h = Heap.from-list [5, 1, 3]
t = Trie.insert "hello" Trie.empty
g = Graph.add-edge "a" "b" Graph.empty

# Priority queue operations
Heap.peek h  # 1 (min-heap)

Pandas-style DataFrames powered by Apache Arrow and SIMD-accelerated CSV parsing. Filter, aggregate, sort, and transform tabular data with columnar storage.

# Load and analyze data
df = DataFrame.from-csv "data.csv"
avg = DataFrame.mean "price" df

# Filter and transform
DataFrame.filter (fn(r) => r.age > 21) df

High-performance lock-free channels: SPSC, MPSC, and unbounded variants. Go-style concurrency primitives built into the runtime.

# Create typed channels
ch = Channel.mpsc 100 |> Result.unwrap

# Send/receive with blocking
Channel.send ch "hello"
msg = Channel.recv ch |> Result.unwrap

# Non-blocking variants
Channel.try-send ch "world"

Built-in HTTP client/server, TCP/UDP sockets, WebSockets, SMTP email, Redis client, file system operations, and compression (tar, zip, gzip).

# HTTP client with ease
resp = HTTP.get "https://api.example.com"
  |> Result.unwrap
body = resp.body

# WebSocket connections
ws = WebSocket.connect "wss://..."
WebSocket.send ws "hello"

Native support for JSON, CSV (SIMD-accelerated), binary encoding, and Base64. Parse and generate data with zero external dependencies.

# JSON parsing built-in
data = JSON.parse "{\"name\": \"Kit\"}"
name = JSON.get "name" data

# SIMD-accelerated CSV
rows = CSV.parse csv-text

First-class testing with test blocks, assertions, and coverage tracking. Run with kit test --coverage for comprehensive test reporting and LCOV/JSON coverage reports—no external frameworks required.

# Define test blocks
test "addition works"
  assert-eq! (add 2 3) 5

# Run with coverage
$ kit test --coverage
Coverage: 45/52 lines (86.5%)

Preconditions and postconditions with @pre and @post. Plus refinement types like {x: Int | x > 0} for type-level constraints.

# Contracts on functions
@pre(n >= 0, "n must be non-negative")
factorial = fn(n) =>
  if n <= 1 then 1
  else n * factorial(n - 1)

# Refinement types
type PositiveInt = {x: Int | x > 0}

CPU timestamp counters, statistical benchmarking, branchless binary search, SIMD operations, and zero-copy I/O for performance-critical applications.

# Cycle-accurate timing
start = Time.rdtsc()
# ... your code ...
cycles = Time.rdtsc() - start

# Statistical benchmarking
stats = Bench.run "op" 100 10000 thunk

Compile Kit programs to WASM for browser deployment, serverless/edge computing, and cross-platform distribution. Works with WASI runtimes like Wasmtime, Wasmer, and Node.js.

# Compile to WebAssembly
$ kit build app.kit --target wasm

# Run with Node.js WASI
$ node --experimental-wasi app.wasm

# Pure computation works perfectly
# Basic I/O via WASI

Concise pattern matching with is, as, and guard keywords. Check patterns, extract values with defaults, and enable early returns without verbose match blocks.

# Pattern check (returns bool)
if status is Passed then "ok" else "fail"

# Extract with default
name = user as Some u -> u.name else "Anonymous"

# Early return on mismatch
guard Ok data = fetch() else Err "failed"

Use .field as shorthand for fn(x) => x.field. Perfect for pipelines and higher-order functions like map and filter.

# Shorthand accessor
get-name = .name
println (get-name {name: "Kit"})  # Kit

# In pipelines
users = [{name: "Alice"}, {name: "Bob"}]
names = users |>> List.map (.name)
# => ["Alice", "Bob"]

User-defined macros with quasiquotation syntax. Create DSLs, generate code, and transform AST at compile time while preserving type safety.

# Define a macro
macro unless cond then-val else-val =
  `(if (not $cond) then $then-val else $else-val)

# Use the macro
result = unless((1 == 2), 42, 0)  # => 42

# Arithmetic macros
macro double x = `($x + $x)

Pony-inspired runtime capability restrictions. Control what your programs can access with --allow, --deny, and --sandbox flags.

# Allow only file access
$ kit run --allow=file app.kit

# Deny network, allow everything else
$ kit run --deny=net app.kit

# Pure sandbox (no I/O)
$ kit run --sandbox app.kit

Opt-in open records with ... syntax. Write functions that accept records with extra fields while still requiring specific fields. Closed records remain the default.

# Open record accepts extra fields
greet = fn(p: {name: String, ...}) =>
  "Hello, " ++ p.name

greet({name: "Kit"})                # OK
greet({name: "Kit", age: 1})       # OK

# {...} accepts any record
accept-any = fn(r: {...}) => "got it"