The Julia Bet — One Language, From Idea to Silicon
What if the oldest rule in computing — fast or friendly, pick one — was never a law? Julia is the language built to break it: write your idea once, in something that reads like math, and have it run like C. Luna and Vestra trace the bet from its founding heresy, through the one idea that makes it work, to the thing that actually matters for AI — differentiating ANY code you ever wrote, and dropping a neural network inside the laws of physics — all the way down to compiling plain code into a custom chip. Then the honest reckoning: it's genuinely radical, and it still hasn't beaten Python. Why? A Breach Protocol deep-dive special.
Cold Open
Eris: Quick one. You've got a brilliant idea for a model. What language do you write it in?
Vestra: Python. Like everyone.
Eris: Right. And then it's too slow. So what happens next?
Vestra: ...someone rewrites the hot part in C++. Or CUDA.
Eris: Someone rewrites it. And now your one idea lives in two languages — the friendly one you think in, and the fast one the machine actually needs. And we just... accept that. We treat it as the weather.
Vestra: Because that's the deal. Always has been. Fast or friendly — pick one.
Eris: That's the thing, though. There's a whole language built on the bet that that's not a real law. That the wall between "easy" and "fast" is something we put there ourselves. It's called Julia.
Vestra: Which has been around long enough that "Julia's about to take over any year now" is basically a running joke.
Eris: And that's exactly the story I want to tell. Because on the merits, it pulled off something genuinely radical. And it still hasn't won. That gap — right, and losing — that's the whole episode.
Vestra: A language that's correct and not winning. Or correct and just early. I genuinely don't know which.
Eris: Neither do I. Let's find out.
Intro
Eris: New here? This is Breach Protocol. We crack open the research and the tools the AI world runs on, and tell you what's actually inside — the substance, not the hype.
Vestra: I'm Vestra. I go after the mechanism — how a thing actually works, and whether it survives a hard look. Luna brings the big idea; I check whether it holds.
Eris: And I'm Luna — I track the thread, the way one idea shows up in five different places. And today's not our usual stack of papers. It's one thing, start to finish. A programming language — Julia — and the very stubborn bet behind it.
Vestra: Which is a slightly strange episode for a show about AI. So let me say why it earns the hour. Julia isn't a chatbot. It's the language a chunk of serious scientific machine learning is being built in — and it makes a promise no mainstream language keeps.
Eris: The promise being: you never have to write your idea twice. One language, from the napkin sketch to the thing that runs fast enough to ship.
Vestra: And I'm going to lean on every step of that, because the beautiful claims are the ones that most need someone leaning.
Eris: Let's get into it.
The heresy — three laws Julia refused to believe
Eris: To get why Julia even exists, you have to go back to three things that scientific computing treated as laws of nature. Bone-deep.
Vestra: Laws. Not preferences.
Eris: Bone-deep assumptions. One — if a language is high-level and pleasant to write, it has to be slow. Two — you prototype in the pleasant language, then rewrite the important parts in a fast one to actually run it. And three — some parts of the system are yours, and some belong to "the experts," and you do not touch those.
Vestra: And all three are really the same wound. Your nice language is a thin, friendly skin. Underneath, it's C and Fortran doing the actual work, and you're not allowed down there.
Eris: And the people who built Julia asked — what if none of that is necessary? What if a single language could be the friendly skin and the fast engine at the same time?
Vestra: Which everyone wants. That's not the hard part. The reason it became a "law" is that every attempt to bolt speed onto an easy language after the fact has failed.
Eris: Say why it fails.
Vestra: Because the moment your friendly language gets popular, all its fast libraries get written in C underneath it. And now the C is load-bearing — it's holding the whole tower up. Try to slide a faster engine in later and everything standing on top cracks. It's not laziness. It's structural.
Eris: So Julia's move wasn't to retrofit. It was — start clean, and make the base language itself fast enough that you never need to drop down to C. Write the math library in the exact same language the user writes in.
Vestra: And here's the detail that actually sold me. Early on, one of their own core pieces — the bit that generates random numbers — was calling out to a C routine for speed. And then someone rewrote it in plain Julia. And the plain-Julia version came out faster.
Eris: So the reflex — "you need C for the fast part" —
Vestra: In their own codebase, it was just wrong. That's a small thing that means a large thing.
Eris: Their whole slogan is basically that: machine performance without giving up human convenience.
Vestra: It's a great slogan. Now I want the mechanism. Because a slogan isn't a reason — it's a promise. How do you actually pull it off?
The one idea — giving the same name to different things
Eris: So the mechanism. And it really comes down to one idea with an unfortunately boring name. Multiple dispatch.
Vestra: Define it in one breath, no jargon.
Eris: Okay. When you write "a plus b," the computer has to choose which "plus" to actually run. Adding two whole numbers is a different machine instruction than adding two decimals — which is different again from adding two whole grids of numbers, two matrices. Multiple dispatch means: pick the right version based on the types of everything involved.
Vestra: And every language chooses somehow. So what's special here.
Eris: Two things. First, Julia decides based on all the arguments at once — not just the first one. And second — it uses that same trick everywhere, at every level. From "add two numbers" all the way up to "add two enormous sparse matrices." One mechanism, top to bottom.
Vestra: And here's the part people skip past, because it sounds like mere tidiness. It's actually how Julia is fast. When the compiler knows exactly which version it's about to call — these two specific types — it can generate tight, specialized machine code for that exact case. The flexibility and the speed come out of the same gear. That's the trick.
Eris: There's a line the creators quote that I keep coming back to. From Poincaré, the mathematician — mathematics is the art of giving the same name to different things. Like the word "determinant." One name. But the actual recipe for a dense matrix and the recipe for a special structured one are completely different procedures.
Vestra: And this flips how you organize a program. Most languages are built around nouns — objects that own their methods. The data's in charge. Julia is built around verbs — the operation is the star, and it adapts to whatever you hand it. And for math, honestly, "solve A x equals b" really is more fundamental than what flavor of matrix A happens to be.
Eris: Verbs over nouns. Hold onto that exact phrase, because it's the thread for the entire rest of this episode.
Vestra: Why. Where does it go.
Eris: It's the reason the next part is even possible. The part where this stops being elegant computer science and starts being the thing that actually matters for AI.
Differentiate anything you ever wrote
Eris: So here's where it gets real for machine learning. To train a neural net, you need one magic ability. Take your code, and automatically get its gradient — basically, for every knob in the model, which way to nudge it to make the answer a little less wrong. That's the engine underneath all of deep learning.
Vestra: Automatic differentiation. And every framework already has it. PyTorch, the rest.
Eris: They do. But there's a catch nobody puts on the box. In those frameworks, that magic only works on their stuff. Their special objects, their built-in operations. The second part of your computation is just ordinary code — a simulator you wrote, some odd loop — it falls outside the magic, and the whole thing refuses to train.
Vestra: And that's the real wall. One of the people in this field put it bluntly — if even one piece of what you're optimizing isn't differentiable-compatible, the network won't train. Not "trains worse." Won't.
Eris: Now the Julia version. Because the whole language is built on that verbs-over-nouns idea — the gradient is just another verb. So you can take code you wrote years ago — a physics simulator, a program that draws 3D images, a model that prices bonds — and just... ask for its gradient. One line. Without rewriting it into anybody's framework.
Vestra: Give me the picture that makes it land.
Eris: They took an old simulator of a trebuchet — a catapult — and wrapped a small neural net around it that learns to hit any target, in any wind. The net steers the physics, and they train the whole loop by differentiating straight through the simulation. On a laptop. Their main ML library actually brags that it's "the library that doesn't make you tensor." Meaning: the model is just code. Nothing special.
Vestra: And there's an even lower, almost more radical version of this. A tool that does the differentiating down at the compiler level — after the code's already been optimized into machine instructions. Which means it stops caring what language you even wrote in. C, Fortran, Julia. It'll differentiate a forty-year-old Fortran routine from some climate model without you porting a single line.
Eris: So the entire back catalog of crusty scientific code suddenly becomes trainable.
Vestra: In principle, yes. That's the dream version.
Eris: And I'll just say the dream version out loud — you can differentiate anything you've ever written.
Vestra: No. And this is exactly where the elegance hits a wall. Not anything. Take randomness — a genuinely random process isn't differentiable in the normal sense, so you need workarounds, and you give something up. And that differentiate-the-compiled-code tool needs to actually see inside the code — hand it a sealed black box and it's stuck. Sometimes the gradient tool even quietly makes your program slower than it should be. It's powerful. It is not magic.
Eris: Fair. Walk me back to the honest claim.
Vestra: The honest claim is: far more of your code is trainable in this ecosystem than in any other one. And — I'll say this plainly — that's the most real thing Julia has. It's a genuine capability that Python can't cleanly match. Not a maybe.
Science that learns its own missing piece
Eris: And this is where it pays off into something I think is genuinely beautiful. Put two things side by side. One — we already know a lot of physics. Equations for how things move, flow, react. Two — neural nets are great at learning patterns from data. So what if you put the net inside the equation?
Vestra: Inside it how. Be concrete.
Eris: You write down the physics you do know. And wherever there's a piece you don't — some term nobody's ever cleanly worked out — you drop a neural net into that one slot. The known physics stays exactly as it is. The net only has to learn the missing part.
Vestra: So you're not asking the network to rediscover gravity from scratch. You fence off the single unknown and aim all the learning at just that.
Eris: Right. And the result that made my jaw drop — they took sparse, patchy data from a predator-and-prey system, the foxes-and-rabbits kind of boom-and-bust cycle. They hid the part that says how the two species interact. And the method recovered the actual hidden equation. Not a curve that happens to fit — the underlying law. And straight pattern-matching, on that same scrap of data, flat-out failed.
Vestra: Because the known structure carries the weight, so the data only has to cover the gap. Their phrase for it is good — a model is worth a thousand datasets. When you already know most of the shape, you need shockingly little data.
Eris: And it scales to real stuff. Climate models can't afford to simulate every little swirl and eddy in the ocean, so they fake those with a rough stand-in. Researchers learned a neural version of that stand-in — and it ran thousands of times faster than the real computation, while staying accurate.
Vestra: Now connect it back. Because this is that verbs-over-nouns idea cashing an enormous check.
Eris: Go on, you say it.
Vestra: There are hundreds of different solvers in this ecosystem for these equations — ones for stiff systems, random ones, ones with time delays. And because everything is organized around operations that adapt to whatever type you give them, a neural net just drops into any of them. Nobody had to go rewrite three hundred solvers to accept a network. They compose for free. In a noun-based world, you'd be hand-welding every single combination.
Eris: So the elegant idea from ten minutes ago is the reason the science actually works at scale. Same idea. Twice.
Vestra: That is the cleanest through-line in this entire language, and I'll give it full credit. ...But. Prior knowledge required. This is not "pour in data, get laws out." You have to already know which chapter is missing. Hand it a true black box, with no physics to stand on, and the magic's gone.
Eris: Agreed. It's a tool for when you know most of the story and you're missing a piece. Which, in real science, is most of the time.
One language, all the way down to the chip
Eris: So if the dream is one language from the idea to the thing that runs fast — how far down does it actually reach? And that floor has been dropping every year.
Vestra: Lower meaning closer to the bare metal.
Eris: Right. First it was — the same code runs on your laptop and on a GPU, the big parallel chips that train modern AI. No rewrite. Then a newer compiler, built on the same differentiation tech we were just talking about, started taking plain Julia and aiming it at the really exotic AI hardware — the chips Google builds for this. It'll even take code written for one brand of chip and rewrite it to run on a completely different one.
Vestra: And this past winter it went one notch lower than I expected. Tell them about the December paper.
Eris: So — they take ordinary Julia and compile it all the way down to a custom chip. Specifically an FPGA. Think of it as a chip you can rewire into whatever circuit you want. Normally, to design hardware, you write in a totally separate, genuinely miserable hardware language. They skip that entirely. Write your algorithm in Julia — get a working chip design out the other end.
Vestra: And notice what that actually is. It's the two-language problem again. Except now it's "the language you think in" versus "the language the silicon needs." Same wound, one level deeper. And Julia is down there chasing it too.
Eris: The same idea, all the way to the transistors.
Vestra: With exactly the honesty I'd want, though. That one's early. The authors come right out and say the tooling is — their words — in its infancy. Some basic things don't work yet; you can't even use certain ordinary programming patterns. It's a proof of direction, not something you'd ship Monday.
Eris: But the direction is the entire point. One language, from the idea in your head down to the actual wires.
Vestra: If it gets there. Which is the perfect moment to turn around and ask the hard question.
So why hasn't it won?
Eris: Because here's what we have to sit with. Everything we just described is real. And Julia is still niche. Python owns this field, completely. So — why?
Vestra: Let me make the case, properly, because it isn't a mystery and it isn't snobbery. There's a paper from a couple years back, by two researchers who clearly love the language — call it a state-of-Julia report. And their verdict is tough.
Eris: Hit me with the hardest part.
Vestra: Start with the boring stuff, because boring stuff decides everything. The tools you need to build serious, trustworthy software — the testing scaffolding, the safety nets that catch your mistakes before your users do — they're thin here, compared to Python's. And in science especially, where a silent bug means a wrong result you publish, that matters more, not less.
Eris: That's the unglamorous plumbing.
Vestra: It's also what production quietly runs on. Next one — the error messages. When Julia breaks, it can hand you a wall of near-unreadable text. Their own community surveys put that right near the top of people's complaints. And it's the flip side of the thing we praised — all that flexibility, all those method combinations, makes the failures genuinely hard to read.
Eris: Okay, but let me push — some of that is fixable polish. It's not a flaw in the bet.
Vestra: It is fixable, agreed. But here's the one that isn't just polish. Who's standing behind it. Julia's main rival for this exact niche has Google's research arm behind it. Julia has no industry giant. And in machine learning, the giants set the defaults — the shared model hub everyone downloads from, the tutorials, the gravity. And all of that is shaped around Python. So a Julia user who wants to share a model often has to wrap it back up in Python anyway.
Eris: So even the bridge out is one-way. You can call into the Python world from Julia, but the rest of the world doesn't easily call back.
Vestra: And the survey result that says all of it — most people who use Julia use it for research. Almost nobody uses it for a business-critical job in production. That right there is the whole gap between "beautiful" and "trusted."
Eris: Here's where I won't fully concede, though.
Vestra: Go.
Eris: Not one of those is the language being wrong. Every single thing you listed is momentum, money, polish, and a missing sponsor — not "the core idea was a mistake." And the paper's own authors basically say that. On paper, they write, Julia should win. Their actual complaint is that the community wandered off into building niche libraries and stopped fixing the foundations — they say Julia needs, more or less, a new constitution. A plan.
Vestra: That's fair. The indictment isn't "bad language." It's "great language, no campaign." And those are very different diagnoses.
Eris: Which is a much sadder kind of story than just being wrong.
What the bet was really about
Eris: So step all the way back. Win or lose — what did Julia actually prove?
Vestra: That the wall was a choice. "Fast or friendly, pick one" — they showed you can have both, in one language, the whole way down. From a simple loop, up to a neural net living inside a physics equation, down to a custom chip. The law everybody obeyed turned out not to be a law.
Eris: And here's the part that matters even if Julia never takes the throne. Ideas don't stay home. The rest of the field was watching. The projects trying to make Python fast, the newer languages promising this exact same thing — they're all chasing the bet Julia made first, and loudest.
Vestra: So the influence runs ahead of the install count.
Eris: It's a little like the band nobody bought a record from, but everybody who saw them live went home and started a band.
Vestra: And I'll go a touch further than I usually do. If what you're doing is scientific machine learning — actual physics, actual equations, not just another chatbot — Julia today does a few things nothing else does as cleanly. That part is not a maybe. The maybe is only whether the world ever shows up to use it.
Eris: Right is not the same as winning.
Vestra: It rarely is. But right tends to outlive the scoreboard.
Wrapup
Eris: So that's the arc. One language, built to kill the oldest compromise in computing — write it nice, then write it again fast. It technically pulled it off. And it's still fighting for the room.
Vestra: And the honest hole is everything that isn't the language itself. The plumbing, the polish, the missing giant. Being right hasn't been enough.
Eris: What are you watching for.
Vestra: Whether the ideas even need Julia in the end. If "differentiate any code you wrote" and "put a network inside the physics" end up shipping in some other language — Julia could win the whole argument and still lose the language. I'd call that bittersweet.
Eris: I'm watching the science. The places where you genuinely know most of the equations and you're missing one piece — climate, biology, materials. If the next big "we found the hidden law" moment comes out of this ecosystem, the popularity numbers stop mattering.
Vestra: Either way — it's that rare case where the most interesting language in the room isn't the most popular one.
Eris: This has been Breach Protocol. We crack the blackbox, so you don't have to.
Vestra: See you next time.