I made a programming language!

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))

Which prints:

Or an exact harmonic sum:

  #lang attalambda

  (print
    (reduce add 0
      (map (lambda (n)
             (unwrap-ok (div 1 n)))
           (range 1 8))))

Which prints exactly:

  363/140

As far as I know, no programming language combines all these features: Michaelson-style type tags built from untyped lambdas, exact rationals backed by binary digit lists, errors as lambda values, and real-world programs where almost all computation stays inside the lambda core. None of those pieces are individually new, but I don't know of another language combining them this way.

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

Wikivibes – Write the encyclopedia you wished existed

Fitting Neural Textures and PBR Material Maps with ES (No Backprop)

Compact Neural Appearance Models for Efficient Gaussian Splatting

Show HN: Cognition-Claude-proxy – Use Devin model catalog with Claude Code

MazeDIY – free browser tool that turns any photo into a printable maze

Blizzard Revives 'StarCraft' Franchise with Open-World Sci-Fi Shooter

Macklemore Removed from Ed Sheeran Tour After "Free Palestine" Statement

Why don't machine learning research agents overfit?

We trained the fly to close B2B SaaS deals

How is climate change affecting conifers and their ability to sequester carbon?

Sixteen Locks Ought to Be Enough for Anybody

Show HN: Rebuno - An open-source runtime for production agents

When LLM judges agree, should we believe them?

Show HN: DNSMint – Give a sandbox its own domain and HTTPS cert in one API call

Black Holes or Black Hole Stars?

When does generative AI qualify for fair use?

I stress-tested Meta Muse until its agent control plane started timing out

Hacking AI customer service agents

Costco Is Rationing Oil and Doubling Its Price as Supply Dwindles

Stalling Installing

Can China's chip ambitions reshape the global tech landscape?

Cops Search Flock Cameras for Reasons of 'LMAO,' 'IDK,' and 'Asdfg'

How my e-reader lost its stripes

Show HN: AttaLambda: a language where types and data are made of untyped lambdas

Running a small LLM in reMarkable 2

MIT creates method to force AI to comply with safety rules

Introduction to AI Engineering

The Medieval Origin of the PhD Dissertation

C++26: Module Improvements

Saudi Arabia Faces 'Worst-Case Scenario' After Being Rebuffed by Trump

Show HN: Raw Binary Program Analysis Tool