From axioms to artifacts.

context -> transformation -> result

Theory without practice is academic. Practice without theory is convention. We occupy the space where computational sciences meet system engineering. Where the Platonic forms of solutions emerge. The Kin Language is the embodiment of our ethos.

We exist at the midpoint between vision and execution. Bring us your problem at any stage — we’ll architect, refine, and build it into a system that works.

Get in Touch

val epsilon86 = (consulting, research, kin)
(consulting,
research, kin)

Consulting val (consulting, _, _) = epsilon86; consulting.render()

We solve engineering problems that resist conventional solutions, with a speciality in system architecture, implementation, and bleeding-edge performance optimization. We assume as little as possible and let the problem space dictate the solution.

Research val (_, research, _) = epsilon86; research.render()

Formal models, type theory, computability, and decidability form the foundation of our research efforts. Our vision is to find unification of these disparate concepts through practical integration. And we publish our findings openly for the good of all humanity.

Computer architecture has been stuck in the same technological prison for 50 years. Things have improved, but performance has been replaced with 10,000 layers of abstraction, each building upon a former legacy. We aim to set things free by understanding the current OS and development software stacks were never built to fully capitalize on modern hardware.

The current way is not the only way.

Kin val (_, _, kin) = epsilon86; kin.render()

Our first major vision of the future. Kin is a highly opinionated programming language that aims to do things differently. It is built from first principles, and includes revolutionary features for a systems language.

See for yourself.

example.kin

/*
  A function that creates new infix operators on the fly.
*/
def make_operator [name : String, op : [T, T] -> T] -> Unit ! Compiler, Context = {
  val ast = (summon Compiler).compile {
    val s = syntax ?x name ?y
    syntax_register!(s)
    fun s [?x : T, ?y : T] -> T
    def s = op
  }
  compiler.exec_in((summon Context).parent, ast)
}

/* Mint three new operators in one fell swoop! */
make_operator "plus"  { a, b -> a + b }
make_operator "minus" { a, b -> a - b }
make_operator "pow"   { a, b ->
  var result = 1
  var i = 0
  while i < b {
    result = result * a
    i = i + 1
  }
  result
}

/* All three are now part of the grammar */
val x = 10 plus 5 minus 3
val y = 2 pow 8
io_println!(as_str!(x) + ", " + as_str!(y))
/* 12, 256 */

Hard problem? Let’s talk.