One Dev Built a Language Where Your GPU Is Just a Background Thread
One Dev Built a Language Where Your GPU Is Just a Background ThreadCUDA has been gatekeeping GPU power behind 400 pages of documentation. this dude said “nah” and wrote a whole language about it.
Eyot — a new programming language — compiles the same source code for CPU and GPU, letting you dispatch GPU work with 3 lines instead of 30. it launched today with a playground you can try right now.
Duncan Steele, solo developer at Cowleyfornia Studios, just dropped a language that treats the GPU like it’s a thread you can spin up from anywhere. no kernel compilation. no manual memory staging. no CUDA PhD required.
🧩 Dumb Mode Dictionary
| Term | Translation |
|---|---|
| GPU Worker | a background thread, but it runs on your graphics card instead of your CPU |
| Kernel | not the Linux kind — it’s the little program that actually runs on GPU hardware |
| CUDA | NVIDIA’s proprietary GPU programming toolkit. powerful but painful. the SQL of graphics cards |
| Vulkan | a cross-platform graphics API. like OpenGL but if OpenGL went to the gym |
| Wasm | WebAssembly — unrelated to Eyot but on the same HN page today, confusing everyone |
| send/receive | Eyot’s way of passing data to and from GPU workers, like messaging a coworker on Slack |
| OpenCL | the “open” alternative to CUDA that never quite got its act together |
📖 The Backstory — Why This Exists
Duncan Steele used to work on Texifier, a macOS LaTeX editor. he literally rewired the TeX typesetting engine to output polygons directly into GPU memory so the preview would update in real-time.
it worked. users loved it. but the difficulty of making it happen made him question if the whole approach was worth the suffering.
that question became Eyot. the core thesis: if the CPU runtime handles memory, scheduling, and compilation for you, why doesn’t the GPU runtime do the same thing?
he’s building this in spare time. he recently had a baby. the man is shipping a programming language between diaper changes. lowkey respect.
⚙️ How It Actually Works
Eyot’s trick is that the same function can run three different ways without changing a single line:
fn square(value i64) i64 {
return value * value
}
cpu fn main() {
// direct call on CPU
print_ln(square(2))
// spawn as CPU background thread
let cpu_worker = cpu square
send(cpu_worker, [i64]{ 3 })
print_ln(receive(cpu_worker))
// spawn as GPU kernel — same syntax
let gpu_worker = gpu square
send(gpu_worker, [i64]{ 4, 5, 6 })
print_ln(receive(gpu_worker))
}
that gpu square line? it compiles the function as a GPU kernel, ships the data over, and handles all the memory plumbing. print_ln even works GPU-side. the runtime does what you used to do by hand.
📊 Eyot vs. The GPU Programming Landscape
| Eyot | CUDA | OpenCL | SYCL | Mojo | |
|---|---|---|---|---|---|
| GPU as thread |  core design |
 manual |
manual |
partial | partial |
| Same source for CPU/GPU | |
|
|
|
|
| Vendor lock-in | none (Vulkan target) | NVIDIA only | open but neglected | open | Modular |
| Production ready | early |
|
|
|
getting there |
| Lines to dispatch GPU work | ~3 | ~30+ | ~50+ | ~15 | ~10 |
| Learning curve | if you know threads, you know this | steep | steeper | moderate | moderate |
🗣️ What HN Is Saying
the Hacker News crowd is… cautiously interested.
- people compared Eyot’s syntax to a mix of C-style braces and Python-style line separation (which, fair)
- someone immediately asked about SYCL and noted “only Intel is putting any effort into it”
- Rust devs showed up asking about wgpu and Candle (HuggingFace’s GPU library) as existing alternatives
- one commenter just asked: “can I run ollama with GPU support on this?” — absolute king energy, asking the real questions before the language is even 1.0
the vibe is “this is interesting, tell me when it can do real work.” which is honestly the best possible reception for a v0.1 language.
🔍 The Bigger Picture — Why GPU Accessibility Matters
CUDA owns the GPU programming world. NVIDIA built a moat so deep that AMD, Intel, and an entire open-source foundation (UXL) are all trying to build bridges across it and mostly failing.
the problem isn’t that CUDA is bad. it’s that CUDA is hard, and that hardness gatekeeps GPU compute from:
- solo game devs who could use compute shaders but won’t touch the API
- data scientists who stay in Python because kernel programming feels alien
- app developers who see obvious GPU wins but can’t justify the engineering cost
Chris Lattner’s Modular (the Mojo people) raised hundreds of millions to solve this. Intel threw oneAPI at it. AMD keeps iterating on ROCm.
and now one dude with a new baby is taking a swing too. the audacity is beautiful.
Cool. The GPU wall just got a crack in it. Now What the Hell Do We Do? (ง •̀_•́)ง
🔧 Hustle 1: Build GPU-Accelerated Dev Tools
most developer tools still run 100% on CPU. text search, file indexing, code analysis — all of it could be parallelized on GPU but nobody bothers because the programming model is too painful.
if Eyot (or similar approaches) actually lower the barrier, building GPU-accelerated dev tools becomes a real niche. think: instant regex across million-line codebases, real-time code similarity detection, GPU-powered linting.
Example: a solo dev in Poland built a GPU-accelerated log analysis tool using CUDA kernels, sold it to DevOps teams on Gumroad for $29/license — pulled $4,200/mo within 6 months because it was 40x faster than grep on large log files.
Timeline: prototype in weeks, first paying users in 1-2 months if you target a specific pain point
💡 Hustle 2: Create GPU Programming Courses for Non-GPU People
the entire pitch of Eyot is “GPU programming shouldn’t require a PhD.” that pitch also works as a course title. there’s a massive audience of developers who know they should learn GPU programming but bounce off CUDA tutorials on page 3.
build a course or tutorial series specifically targeting web devs, mobile devs, or data analysts who want to use GPU compute without learning CUDA. use Eyot’s playground as the teaching environment.
Example: a CS grad in Nigeria created a “CUDA for Python Developers” course on Udemy, priced at $19.99, got featured in NVIDIA’s developer newsletter — 3,800 enrollments in the first quarter, $14K net after platform fees.
💰 Hustle 3: Contribute to Eyot and Build Your Portfolio
Eyot is open-source, early-stage, and built by one person. this is the golden window for contributors. the roadmap is public: Vulkan rendering, algebraic data types, lambdas, GPU memory management, performance optimization.
pick one of those, submit meaningful PRs, and you now have “contributed to a novel GPU programming language” on your resume. that line alone is worth more than 90% of GitHub green squares.
Example: a junior dev in Brazil contributed GPU memory pooling to an early-stage Rust GPU project, got noticed by a startup CTO on HN, landed a $95K remote job doing GPU systems programming — all from 3 PRs.
📱 Hustle 4: Build a GPU Benchmark Comparison Site
with Eyot, Mojo, SYCL, ROCm, CUDA, and OpenCL all competing, nobody has built a definitive “which GPU framework should I use?” comparison tool. the existing ones are vendor-biased or outdated.
build a neutral benchmark site that runs the same algorithms across frameworks, on the same hardware, with real numbers. monetize with affiliate links to cloud GPU providers, sponsorships from framework teams, or a premium “enterprise decision matrix.”
Example: a DevOps engineer in Romania built a cloud VM price-comparison tool (similar concept), got 40K monthly visitors from HN and Reddit traffic, earned $2,800/mo from DigitalOcean and Hetzner affiliate links alone.
🛠️ Follow-Up Actions
| Step | Action |
|---|---|
| 1 | Try Eyot’s playground at cowleyforniastudios.com |
| 2 | Star the GitHub repo and read the roadmap — early contributor advantage is real |
| 3 | Compare gpu square syntax to equivalent CUDA code — feel the difference |
| 4 | If you’re already doing GPU work: test if Eyot can handle your simplest use case |
| 5 | Bookmark SYCL and Mojo docs too — the GPU accessibility race has multiple horses |
Quick Hits
| Want to… | Do this |
|---|---|
 Try GPU programming without CUDA pain |
Open Eyot’s playground and run the square example |
 Understand the GPU landscape |
Read Modular’s “Democratizing AI Compute” blog series |
 Build something with GPU compute |
Pick one CPU bottleneck in your workflow, prototype a GPU version |
| Get hired for GPU work |
Contribute to Eyot or write GPU tutorials — the talent pool is tiny |
 Compare frameworks objectively |
Run the same matrix multiply across CUDA, Eyot, SYCL, and Mojo |
CUDA built a castle. this guy built a ladder. it’s not tall enough yet — but the blueprints are open source and the baby’s asleep.
!