I call it AttaLambda.
The idea is this: a usable Lisp-shaped language where all the meaningful computation is done in untyped lambda calculus. Logic, arithmetic, data structures, control flow, even the types — all untyped lambdas. A small, explicit Racket layer sits at the boundary to handle the outside world, plus some macros for syntactic sugar.
This is its story:
A couple years ago, I wanted to play with untyped lambda calculus and go beyond where tutorials usually stop. They show booleans, numbers, arithmetic, maybe the Y-combinator — and then stop. I wanted them to keep going.
So I started a project called All The Lambdas. Using Racket set to lazy, I used only one Racket construct for actual computation — lambda — and built integers, rationals, lists, binary digit-list number encodings, search algorithms, and more.
Then I found Functional Programming Through Lambda Calculus by Greg Michaelson. In it, Michaelson sketches the bones of a language built in untyped lambda calculus, including a type system where typed objects are themselves pair functions containing a type tag and value.
I found that intriguing and implemented and extended the idea, still entirely with untyped lambdas. I don't have a background in programming language theory, so I was figuring it out as I went.
Then I stopped tinkering with it for a while.
Recently I came back and thought: why not turn this into a real usable language with the help of coding agents? I reused most of All The Lambdas as the foundation.
Thus AttaLambda was born.
Some additional details:
* Rat, its number type, uses binary digit-list encodings instead of Church numerals, so numbers scale with their number of binary digits rather than their value
* errors are lambda-encoded values, not Racket exceptions, and propagate through the language like ordinary data
* the Racket host only performs irreducibly external operations; even things like HTTP parsing, routing, and response construction stay in the pure lambda world
* recursion uses lambda-calculus recursion: no loops or true self-reference, just the Y-combinator underneath
* automated purity checks catch accidental cheating, like native computation leaking into the pure parts
* syntax like multi-argument lambdas, let, cond, and list is just macro sugar that reduces to unary lambdas and application
A couple code examples: (short of print, every single thing here reduces to unary untyped lambdas)
Factorial:
#lang attalambda
(rec factorial n =
(cond
((eq n 0) 1)
(else (mult n (factorial (sub n 1))))))
(print (factorial 10))
3628800
#lang attalambda
(print
(reduce add 0
(map (lambda (n)
(unwrap-ok (div 1 n)))
(range 1 8))))
363/140
Download: https://github.com/kserrec/attalambda/releases/tag/v0.7.0
Code: https://github.com/kserrec/attalambda
Original All The Lambdas: https://github.com/kserrec/all_the_lambdas
Show HN: AttaLambda: a language where types and data are made of untyped lambdas
attalambda.com