A safe, expression-oriented language with algebraic effects and familiar syntax.

hica is a safe, expression-oriented language with a functional style and familiar syntax.

Features include:

• Hindley-Milner type inference
• Algebraic effects
• Expression-oriented design
• No nulls or unchecked exceptions
• Compilation to C, JavaScript, and WASM

Under the hood, hica is implemented in Koka and inherits Koka's algebraic effect system and Perceus memory management.

hica stands for Hindley-Milner Inference Compiler with Algebraic effects.

Visit hica's website for a tour of the language.

Design Goals

• Safe by default – no null, no unhandled exceptions; errors are values (Result, Maybe).
• Expression-oriented – everything returns a value: if, match, and blocks are all expressions.
• Functional-first – immutability by default, higher-order functions, and pattern matching at the core.
• Minimal ceremony – Hindley-Milner type inference means you rarely write annotations; the language gets out of your way.
• Effect tracking – side effects (I/O, state, exceptions) are tracked by the type system, not buried in function bodies.
• Predictable memory management – inherited from Koka's Perceus reference counting; no GC pauses, no manual allocation.
• Familiar syntax – curly braces, let, fun, match, if, and the => expression-bodied shorthand.

Install

Linux / macOS / Chromebook:

curl -fsSL https://www.hica.dev/install.sh | sh

This installs the latest release binary to ~/.local/bin. Override with HICA_INSTALL_DIR:

curl -fsSL https://www.hica.dev/install.sh | HICA_INSTALL_DIR=/usr/local/bin sh

Windows (PowerShell):

irm https://www.hica.dev/install.ps1 | iex

Build from source

Requires Koka ≥ 3.2.

git clone https://github.com/cladam/hica.git
cd hica
make release

Quick Start

Create a file hello.hc:

fun main() {
  println("Hello, world")
}

Then run it:

hica run hello.hc

Other common commands:

# Compile to a binary
hica build hello.hc -o hello

# Type-check without emitting
hica check hello.hc

# Format source
hica fmt hello.hc

Examples

Expression-bodied functions

fun double(x) => x * 2

fun main() {
  let result = double(21)
  result
}

Match expressions

fun describe(x) => match x {
  0 => "zero",
  1 => "one",
  _ => "many"
}

Lambdas

fun apply(f, x) => f(x)

fun main() {
  let sq = (n) => n * n
  apply(sq, 5)
}

Type annotations

fun add(a: int, b: int) : int => a + b

fun main() {
  let x: int = 42
  println(add(x, 8))
}

Maybe and Result types

fun safe_divide(a, b) =>
  if b == 0 { Err("division by zero") }
  else { Ok(a / b) }

fun main() {
  match safe_divide(10, 3) {
    Ok(n)  => println(n),
    Err(e) => println(e)
  }
}

FizzBuzz

fun fizzbuzz(n) =>
  if n % 15 == 0 { "fizzbuzz" }
  else if n % 3 == 0 { "fizz" }
  else if n % 5 == 0 { "buzz" }
  else { show(n) }

CLI

Command	Description
build	Compile a file to a binary
run	Compile and run a file
check	Type-check source without emitting
fmt	Format source
test	Run tests in a file
new	Create a new project
repl	Start an interactive shell

Run hica help <command> for details on any command.

Inspirations

• Koka – language with algebraic effects and Perceus memory management
• Rust – syntax, safety mindset, and the match expression
• F# – functional-first style, pipelines, and type inference ergonomics
• C# – the => expression-bodied shorthand and query syntax
• Python – approachable, expressive lists and comprehensions

Status

hica is under active development.

The language is usable today for experimentation and personal projects, but some features and APIs may change between releases.

Why hica?

hica aims to combine:

• the readability of Python,
• the safety mindset of Rust,
• the ergonomics of F#,
• and the algebraic effects of Koka,

while keeping a familiar curly-brace syntax.

Compilation Pipeline

.hc source → Lex → Parse → Desugar → Type Check → Emit Koka (.kk) → Koka Compiler → C/JS/WASM

Each phase is implemented as a Koka module using algebraic effects for compiler state (diagnostics, fresh type variables, symbol scopes).

Technical Stack

Component	Approach
Implementation	Koka 3.x
Parsing	Recursive descent with Pratt expression parsing
Type system	Hindley-Milner with unification
Name resolution	Declaration-aware marshalling (hc_ prefix)
CLI argument parsing	klap (clap-inspired, in-tree)
Memory management	Perceus (inherited from Koka target)
Backend target	Koka (.kk) → C / JS / WASM via Koka
Runtime	Koka standard library and runtime

Licence

Apache License 2.0 – see LICENSE.