Julia language keeps AI honest in engineering
The gap between what artificial intelligence promises and what it actually delivers is nowhere more dangerous than in engineering, where a machine learning model might suggest a design that looks plausible but violates the laws of thermodynamics. A rocket engine that ignores fluid dynamics does not fail gracefully; it explodes. The stakes of this divide are measured in hardware costs, safety certifications, and sometimes human lives. Yet a small team of researchers has spent nearly two decades building a solution that does not merely paper over this gap but enforces physical reality at the code level. Their work has quietly become the standard for how AI can be trusted with the hard problems of the physical world.
The origin of this effort was not a grand vision but a series of exasperated emails exchanged in 2009 between researchers who were tired of the programming languages available to scientists. These languages forced a brutal trade-off: either write code that was easy to understand but painfully slow, or invest weeks rewriting everything in a faster language that was rigid and unforgiving. A scientist who built a working simulation in one language would often have to rebuild the entire program from scratch just to run it at a practical speed. The frustration was not about convenience; it was about the pace of discovery itself. When every iteration of a model requires a full reprogramming effort, the scientific process slows to a crawl. The emails turned into a research project at MIT with the mission of building an easy-to-use, high-performance programming language called Julia, designed for scientific research, data analysis, and modeling complex systems such as jet engines, drugs, financial markets, and robots
What emerged from those early discussions was a language with a fundamental insight at its core: the way code compiles should depend on the type of data it is processing. This “just-in-time compilation” approach allowed Julia to combine the ease of use of Python with the raw speed of C. For the first time, scientists and engineers could write code that felt natural and expressive without sacrificing the performance needed for serious computation. The language did not force researchers to think like programmers; it adapted to how they already thought about their problems. This was not a minor technical detail but a philosophical shift in what a programming language could be. Julia’s creators understood that the barrier between scientific ideas and computational validation was not a lack of intelligence but a lack of appropriate tools.
Julia’s secret sauce is in the way it compiles code depending on the type of data being used. Such “just-in-time compilation” makes Julia faster and more flexible than other numerical programming languages. When a researcher writes a simulation of ocean currents or a financial market, the language can optimize the execution in real time based on the actual data flowing through the system. This is not a static optimization done once at the start; it is a continuous adaptation that happens as the computation progresses. The result is a platform that can handle the messy, unpredictable nature of real-world data without requiring the programmer to anticipate every possible scenario in advance.
The founders of this effort came from diverse corners of the academic world, united by a shared frustration. Viral Shah, who would become the CEO of the company spun out of this research, articulated the core question that drove them: “Scientists and engineers are not programmers. Building scientific applications with multidisciplinary teams of scientists, engineers, and programmers is challenging. We asked: What if you could equip the scientists and engineers with a programming language that allowed them to express their ideas at a high level and also get great software performance?” [2] This question reframed the entire problem. Instead of demanding that scientists become better programmers, the goal was to create a tool that met scientists where they already were. The language needed to respect the way researchers think, not force them into a foreign cognitive framework.
Making programming easy for non-programmers has been a north star for JuliaHub’s founders, who include Julia co-creators Shah, MIT professor of mathematics Alan Edelman, Jeff Bezanson, and former MIT research scientist Stefan Karpinski. [2] The team’s philosophy was simple: the best tool is the one you do not have to think about using. This principle guided every design decision, from the syntax to the way errors are reported. When a scientist hits a problem, the language should help them solve it, not add another layer of confusion. The founders were not interested in building a language for other language designers; they were building a tool for people who had real problems to solve in the physical world.
The trajectory from those early emails to a global community of over one million users was not linear. The MIT researchers announced Julia with a blog post in 2012, and the response surprised them. “We figured it would take 10 years before anyone was interested, but we said, ‘Patience is a virtue, so let’s do it,’” Edelman recalls. [1] The patience paid off faster than expected. Researchers around the world recognized immediately that this was a solution to a problem they had been living with for years. The language spread through word of mouth, through academic papers, through the simple experience of watching a colleague write code that ran faster and was easier to read than anything they had used before. By 2015, the demand for support and continued development was strong enough that the team decided to start a company, JuliaHub, to focus on the work full-time.
The applications that emerged from this community read like a catalog of humanity’s most complex challenges. Julia has been used to simulate computer circuits, detect health disparities, model global climates and oceans, and analyze brain activity. Astronomers have used it for imaging black holes, peering into the most extreme environments in the universe. Engineers have used it to design race cars and airplanes, systems where the margin between success and failure is measured in fractions of a second. The language has modeled the behavior of tiny atoms and the dynamics of entire semiconductor manufacturing processes.
One of the most consequential applications came during a global health crisis. After someone built a pharmaceutical modeling platform in Julia, it was used to accelerate development of Moderna’s Covid-19 vaccine. The speed of that development was not just a triumph of biology but a demonstration of what happens when computational tools remove bottlenecks from the scientific process. In another case, researchers used Julia to create a program for avoiding aircraft collisions. They found it ran about 50 times faster than an earlier version built on Python. That is not an incremental improvement; it is the difference between a system that can react in real time and one that can only analyze data after the fact. Engineers at Meta used Julia to develop a better audio codec for WhatsApp’s 4 billion users, improving the quality of billions of conversations with a single optimization
The real test of Julia’s philosophy came when the team began integrating artificial intelligence into their platform. In June of 2025, JuliaHub launched Dyad 1.0 as a research agent to accelerate programming, followed by Dyad 2.0 in December. The latest version, Dyad 3.0, released in April 2026, represents a new level of ability and autonomy for designing complex systems. This is where the original vision of making programming accessible to non-programmers collides with the promise and peril of generative AI. The team understood that simply handing an AI agent a problem and letting it generate code was not enough. The AI needed guardrails, and the most important guardrails are the laws of physics themselves.
“One important thing about Dyad is that it is a physics compiler and hence enforces physical laws,” Shah explains. “General AI systems often solve physical problems in ways that violate physical laws. When using the Dyad agent, it will detect such violations and guide the agent in the direction of the physically correct solution. We expect it will decrease design times in product engineering by orders of magnitude, leading to months of work being accomplished in hours.” [2] This is a profound statement about the relationship between AI and reality. Most AI systems are trained on patterns in data, which means they can confidently reproduce patterns that are physically impossible. A language model might suggest a bridge design that looks structurally sound but would collapse under its own weight. The Dyad approach embeds physical constraints directly into the AI’s reasoning process, catching violations before they become expensive mistakes.
The practical implications of this approach are staggering. Engineers are already using Dyad to direct autonomous AI agents as they work through physics simulations, safety analyses, quality controls, and more. The system does not just generate code; it verifies that the code produces physically valid results. This is the difference between a suggestion and a solution. “With Dyad 3.0, you can upload data and design documents and the system will design an entire aircraft for you,” Shah says. “Working with customers like Boeing, we are building agentic hardware design capabilities for engineers. Simplistically, you want to say, ‘Okay computer, build me a plane’; upload the design documents; and have the system account for all the physics, compile all the code, verify everything, and build the entire design agentically.” [3]
This vision of autonomous design is not about replacing engineers but about freeing them from the mechanical drudgery of their work. An engineer who spends weeks calculating whether a particular component can withstand the stresses of flight is not doing engineering; they are doing data entry. The Dyad system handles those calculations, checks them against physical laws, and presents the engineer with a design that is already validated. The engineer’s role shifts from computation to judgment: does this design meet the requirements, is it cost-effective, does it align with the broader goals of the project? This is a fundamental redefinition of what it means to be an engineer in the age of AI.
The impact of this approach can be seen in the classroom as well as the boardroom. Edelman has taught a class on Julia with students from nearly every department at MIT, and the results are consistently surprising. One student recently used Dyad to model how robots move around in space, a problem that would traditionally require months of specialized knowledge in both robotics and computational physics. Another used it to build a rocket engine, a task that sounds like the work of a seasoned aerospace engineer rather than a student in a single semester. “At the end he said, ‘I couldn’t believe how easy that was — I just got a rocket engine!’” Edelman recalls. [1] This is not a story about a student being handed a solution; it is a story about a student being given a tool that lets their ideas become reality without a decade of programming experience.
The broader lesson from Julia’s journey is that AI’s value is not measured by the sophistication of its algorithms but by the reliability of its outputs. A system that generates beautiful code that violates physics is not helpful; it is a hazard. The Julia approach inverts the typical AI development process. Instead of starting with the AI and hoping it produces good results, the team started with the domain knowledge and built the AI around it. The physics compiler is not an add-on feature; it is the foundation upon which everything else is built. This is why the system can be trusted with problems where failure is not an option, like designing satellites or heat pumps that must operate flawlessly for decades.
The history of computing is full of tools that promised to make programming accessible to everyone, and most of them failed because they simplified away the hard parts. Julia succeeded because it did not simplify the hard parts; it made them easier to handle. The language does not hide the complexity of physics from the user; it makes that complexity manageable. This is a crucial distinction. A tool that hides complexity creates a false sense of security; a tool that manages complexity creates genuine capability. When an engineer uses Dyad to design a satellite, they are not blindly trusting the AI. They are using a system that has been built on decades of verified physics and tested against real-world constraints.
The question of who defines what is good enough has haunted the AI industry since its inception. In many applications, the answer is vague: a chatbot is good enough if it sounds plausible, a recommendation system is good enough if it keeps users engaged. But in engineering, the standard is absolute. A design either works or it does not, and the consequences of failure are measured in dollars and lives. This is why the Julia approach matters beyond the specific applications it enables. It demonstrates that AI can be held to rigorous standards, that it can be built to respect the fundamental laws of the universe rather than just the patterns in its training data. The physics compiler is a proof of concept for a broader principle: AI should be accountable to reality.
The community that has grown around Julia is a testament to the power of this philosophy. Researchers come to the language for practical reasons but stay for reasons that are harder to articulate. “Researchers come up to me and say, ‘I tell my supervisor I’m using Julia because it’s fast, but don’t tell them I’m using Julia because it’s really fun,’” Edelman says. “The key thing is Julia’s abstractions. A lot of times a coding language forces you to solve the one problem you’re thinking about. Julia’s language makes it so you’re solving not only the problem you’re thinking about, but other people’s problems around the world too. It encourages you to solve problems more generally.” This generality is not an accident; it is a design choice. The language was built to encourage users to think beyond their immediate problem, to create solutions that others can build upon.
The journey from those first exasperated emails to a platform that can design an entire aircraft has taken nearly two decades. It has involved countless iterations, failures, and moments of doubt. The researchers who started this project did not know if anyone would care about their creation. They built it for themselves, for the simple reason that they were tired of fighting against their tools. The fact that it has become a global standard for scientific computing is a testament to the universality of that frustration. Every scientist who has ever rewritten a simulation in a faster language, every engineer who has waited hours for a computation to finish, every student who has struggled to translate an idea into code knows exactly why Julia exists.
The current state of AI development is characterized by a kind of gold rush mentality, where companies race to deploy the most impressive demos without fully considering the consequences. The Julia approach offers a counter-narrative: a story about building AI that is genuinely useful because it is genuinely constrained. The physics compiler does not limit what the AI can do; it focuses the AI on what is actually possible. This is not a reduction of ambition but a refinement of it. A rocket engine designed by Dyad is not less impressive because it must obey the laws of thermodynamics; it is more impressive because it actually works.
The engineers who use Dyad are not passive recipients of AI-generated designs; they are active participants in a new kind of collaboration. The AI handles the computational heavy lifting, the verification of physical laws, the compilation of code. The engineer provides the judgment, the context, the understanding of what the design needs to accomplish. This is a partnership, not a replacement. The language of this partnership is one of mutual respect: the AI respects the engineer’s expertise by providing reliable results, and the engineer respects the AI’s capabilities by directing it toward meaningful problems. The result is a workflow that is faster, more accurate, and more creative than either human or machine could achieve alone.
The future of this work is not limited to aircraft and satellites. The same principles that allow Dyad to design a rocket engine can be applied to any complex system where physical constraints matter. Medical devices, energy systems, transportation networks, manufacturing processes: all of these are governed by physical laws that must be respected. The Julia approach offers a way to make AI useful in all of these domains, not by ignoring the constraints but by embracing them.
The voice of those affected by this technology is best heard in the words of the students and researchers who use it. They do not talk about benchmarks or breakthroughs; they talk about the experience of having their ideas become real. The student who built a rocket engine in a semester, the researcher who modeled a black hole, the engineer who designed a heat pump that works: these are the people who define what good enough means. For them, good enough is not a marketing slogan; it is a measurable outcome. The tools they use must produce results that are physically valid, computationally efficient, and practically useful.
The story of Julia is not a story about technology; it is a story about the relationship between human creativity and the constraints of reality. The language was built to give scientists and engineers the freedom to express their ideas without being limited by the tools available to them. It was built on the insight that the best tool is one that disappears, that lets the user focus on the problem rather than the mechanics of solving it. This insight has guided every decision the team has made, from the design of the language to the development of the AI platform.
As the world grapples with the promise and peril of artificial intelligence, the Julia approach offers a model for how to build AI that is genuinely trustworthy. It does not rely on vague assurances of alignment or safety; it relies on the hard, verifiable constraints of physics. A system that cannot violate the laws of thermodynamics is, by definition, safer than one that can. A system that checks its outputs against physical reality is, by definition, more reliable than one that does not. This is not a complete solution to the challenges of AI, but it is a foundation upon which such solutions can be built. The quiet work of the Julia team has shown that AI can be both powerful and accountable, that it can be both creative and correct.
Sources
1. MIT
2. JuliaHub
3. Boeing
4. Meta