itguyeric/podcast
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Page: ITG031 building a language
Pages
Home ITG019 subscriptions ITG020 first inference ITG021 ubuntu community ITG022 human in the middle ITG023 keep it techie ITG024 ttrpg ITG025 homelab sla ITG026 open source password manager ITG027 45homelab ITG028 what is a homelab ITG029 engineer the business ITG030 state of linux ITG031 building a language Template Episode Guide
1 ITG031 building a language
Eric the IT Guy edited this page 2026-08-19 09:52:38 -05:00
Table of Contents
episode airdate recorded status short_title full_title description summary guest guest_title guest_links headshot youtube_url youtube_id fireside_player slug tags topics_to_avoid
031 2026-10-13 prep Building a Language Building a Programming Language with a Local AI, with Jim Duey | The IT Guy Show 031 Jim Duey has been chasing the next great functional language for over a decade. Now he is building it with a local AI model on his own hardware, and the process turns out to be as interesting as the language. Jim Duey and I get into language design, and what it is actually like to build a compiler with a 27B model running on your own GPU. Jim Duey Functional programming and language design, creator of Toccata
https://github.com/jduey
host.png itguyshow-ep31-building-a-language
The IT Guy Show
Guest
Programming
AI
Homelab

Abstract

Jim Duey has been giving talks called things like "The Next Great Functional Programming Language" since 2016, and he is still at it. He wrote monad libraries for Clojure, a Java bytecode compiler in Clojure, and Toccata, a Clojure dialect that compiles to a native binary through Clang. Building languages is not a phase for him.

I met Jim at DevOps Days KC and asked him to come talk about the language he is working on now. His answer was better than the question. The language is not ready, but the way he is building it might be the more interesting story: he is doing it with a local AI model, currently Qwen 3.8 27B running on an RTX 5090 sitting in his own machine.

So this one goes two directions at once, and both are ones my audience cares about. What it takes to design a language and why anyone still bothers, and what it is actually like to do serious, precise, unforgiving work with a model you host yourself. Not a chatbot demo. Compiler work.

Hook

Jim Duey has been trying to build the next great functional language for a decade. This year he added a collaborator: a 27 billion parameter model running on a graphics card in his own house.

Agenda

Introductions

  • Who are you?
  • What do you do?
  • What do you do for fun?
  • How did you fall into language design in the first place?

1. Why Build a Language

  • The honest question first: the world has plenty of languages. Why make another?
  • The through-line from protocol-monads and mini-kanren to Toccata, a Clojure dialect that compiles native through Clang
  • What Toccata taught you, and what you would do differently now
  • What is the new one trying to fix that nothing else does?

2. The Local AI Part

  • The setup: Qwen 3.8 27B on an RTX 5090, running locally. Why local rather than an API?
  • What it costs to get there, in money, watts, and patience
  • Which parts of compiler work does it genuinely help with, and which parts does it get confidently wrong?
  • How do you verify what it gives you? Compiler bugs are not the kind that announce themselves
  • Has it changed how you design, or only how fast you type?

3. The Practical Homelab Angle

  • For someone who wants to run a serious model at home: what actually matters, and what is a waste of money?
  • VRAM as the real constraint, and where a 5090 stops being enough
  • Where quantization helps and where it quietly ruins the output
  • What would you tell someone whose plan is "I'll just try it on the GPU I already have"?

4. The Bigger Question

  • Does a local model change what one person can realistically build alone?
  • Where the hype and the reality diverge in your day to day
  • What still has to come out of your own head
  • What are you most looking forward to, and what worries you?

Wrap Up

  • Where to find Jim and the project
  • When can people actually see the language?
  • Final thoughts and key takeaways

Closing

  • Like / Subscribe
  • Next:
  • Sign-off: on behalf of my guest, Jim Duey, and myself, Eric the IT Guy Hendricks

Keywords

Jim Duey, Toccata, Clojure, functional programming, programming language design, compiler, Clang, local AI, local LLM, Qwen, RTX 5090, self-hosted AI, homelab AI, quantization, VRAM, monads, mini-kanren, DevOps Days KC

Links

Blog Post

Draft. Rewrite from the transcript after recording.

I asked Jim Duey to come on the show and talk about the programming language he is building. He told me it is not ready, but that the process might be more interesting, because he is building it with a 27 billion parameter model running on a graphics card in his own house. He was right.

{{< episode >}}

A few things worth carrying away from this one:

  • Language design is a long game. Jim has been at this since the Clojure monad libraries, through Toccata compiling native via Clang, and he is still going. We got into why anyone builds a language at all.
  • Local AI on compiler work is a real test. Compilers do not tolerate almost-right. We talked about where the model genuinely helps, where it is confidently wrong, and how he verifies any of it.
  • The hardware conversation is a homelab conversation. VRAM, quantization, power, and what actually matters if you want to run something serious at home.

Social Posts

LinkedIn

Draft. Rewrite after recording.

I asked Jim Duey to come on the show to talk about the programming language he is building. He said the language is not ready, but the process might be more interesting, because he is building it with a local AI model on his own hardware.

Qwen 3.8 27B. RTX 5090. Sitting in his house.

Jim has been chasing the next great functional language for a decade, from Clojure monad libraries to Toccata, which compiles to a native binary through Clang. So episode 031 goes two directions at once.

A few things you'll pick up:

  • Why anyone still builds a programming language, and what Toccata taught him
  • Where a local model genuinely helps with compiler work and where it is confidently wrong
  • How you verify AI output when the bugs do not announce themselves
  • What actually matters if you want to run a serious model at home: VRAM, quantization, power

[PASTE YOUTUBE URL]

#LocalAI #Homelab #ProgrammingLanguages #Clojure #OpenSource

Twitter/X

Draft. Rewrite after recording.

Jim Duey has been chasing the next great functional language for a decade. Now he is building it with Qwen 27B on an RTX 5090 in his own house. For 031 we get into language design, and where a local model helps with compiler work vs where it is confidently wrong. [PASTE YOUTUBE URL] #LocalAI #Homelab

Bluesky / Mastodon

Draft. Rewrite after recording.

I asked Jim Duey on the show to talk about the language he is building. He said it is not ready, but the process might be more interesting: he is building it with a 27B model on an RTX 5090 in his own house. For 031 we cover language design, compiler work with a local model, and what actually matters to run one at home.

[PASTE YOUTUBE URL]

#LocalAI #Homelab #ProgrammingLanguages #OpenSource

YouTube Ad

  • Final URL: [PASTE YOUTUBE URL]
  • Display path 1: IT-Guy-Show
  • Display path 2: Local-AI
  • Short headline: The IT Guy Show
  • Long headline: He Is Building A Programming Language With An AI In His Own House
  • Description: Linux, homelabs, and open source for the people who actually run the infrastructure.
  • CTA: Watch Now

Production Notes

  • Jim said "You bet" to an episode back in May 2026 after Eric met him at DevOps Days KC. On 2026-08-18 he clarified: the language is not ready, but "the process might be interesting. I'm using a local AI model to work on it. Just upgraded to Qwen 3.8 27B and it's pretty amazing. Running on an RTX 5090 card."
  • That reply is why this guide leads with the local AI angle rather than the language. Confirm with Jim that he is comfortable with that framing before recording, since he pitched the process as a secondary idea.
  • Background worth knowing on air: he wrote protocol-monads and a mini-kanren implementation for Clojure, a Java bytecode compiler in Clojure, and Toccata. He gave talks titled "The Next Great Functional Programming Language" (2016) and "Towards the Next Great Language" (2017), so the decade-long arc is a real story, not a stretch.
  • Pairs well with ITG020 "First Boot, First Inference" as a callback.
  • Recording after the Linux Prepper interview.