The language
that writes
the others
Aucoda spent a decade building Au: a declarative language that turns one readable program into expert code across every major language. Around it sat a browser IDE, a debugger, and a full course. This page is its record.
Au ran in production for years. Graduates learned it in two weeks and shipped real systems with it, for the NHS, PwC, HM Revenue & Customs, the Metropolitan Police and Marks & Spencer. This page is the history of Au: the language, the platform around it, and the developers it made.
01What Au is
Au is a compiler that does not target a chip. A normal compiler targets an instruction set — x86, ARM, byte code. Au targets other languages instead. It uses every other language as its instruction set. The language is not fixed. Au is a broker, and at compile time it brokers for the right instructions.
You write a program once, in a form a beginner can read, and Au writes the expert code underneath it. One code base becomes an iOS app, an Android app and a web app at once.
The design keeps three things apart. A Model is Au's own vocabulary for a class of application, such as a console tool, a web service, an interface, or a task. The compiler lowers your program into Model Object Code, an intermediate form. An Implementation turns that intermediate form into expert code for one target. The Swift Implementation writes expert Swift. The Python Implementation writes expert Python.
You choose a build by pairing a Model with a target. When a target cannot honour a Model, the compiler stops the build. It does not emit broken code.
to write, on average
to deliver a project
generated by Au
in production
02How a build moves
A build runs through the compiler in a fixed shape. A front end reads Au. An intermediate form sits in the middle. A set of interchangeable code generators sits at the back.
This is the shape of a normal industrial compiler. The back end is what differs. It is not one target but many, and each is held to code an expert in that language would accept. The same Au source runs the full stack.
Au extends at two clean points. You extend the language by extending the Model. You extend the output by adding an Implementation. Implementations are written in a companion language, Autron — automatic transformation. A team can teach Au a new target in about two weeks, or bend an existing target to its own coding standards.
The compiler shipped in two forms. The local version ran on your machine, inside your source control and build. The Lambda version ran the compiler as an AWS function, so you could compile from anywhere with no infrastructure to manage.
03The platform
Au was a complete product, not only a language. Five parts worked together: the compiler, the browser IDE, Catalyst, the interactive tutorial, and a debugger that runs Au in Au. The sections that follow take each in turn.
The IDE is Automic. It runs entirely in the browser, with nothing to install. Projects live as cards on a dashboard. Creating one is a guided flow that scaffolds the right files for the type of application you pick. Inside, a full editor gives you file navigation, an integrated console, live compiler output, and Git for source control.
Under the surface the platform is one system in four codebases.
| Part | What it does |
|---|---|
| Compiler au-39 | Turns Au into expert code for every target. |
| IDE Automic / auShell | The browser editor: highlighting, autocomplete, source control, and the debugger. |
| Runtime auAppliance | Drives the compiler, runs what it builds, and serves it in the browser as if it were native. |
| On-demand build au-39-lambda | The same compiler as a cloud function, so a browser tab is enough to learn on. |
04Debug in Au, in the browser
Au debugs Au. It debugs in the language you wrote, in the browser, in Au. You set breakpoints, step through the code, and watch your variables. A live preview of the application runs beside the code. Here a weather app renders on a simulated phone as the Au drives it. The numbered points match the markers on the screenshot.
- Breakpoint. When a breakpoint is reached, the application stops so you can step through the code. Add or remove one by double-clicking the line number in the gutter.
- Current position. The editor highlights exactly where you are in the code while debugging.
- Debug variables. Variables fill the side panel as you step through the code, shown in Au.
- Debug controls. The toolbar drives execution: Debug, Continue to the next breakpoint, Step Over a line, Step Into a function, and Step Out Of a function.
One idea sits under all of this. Debugging is a build target. Ask for a debug build and the compiler writes the debug lines into your program. Every Au statement then reports itself as it runs. So the debugger steps Au, never the generated code beneath.
The breakpoints travel with the program across the network. Put one on a button handler and another inside the web-server function it calls. Click the button. You pause in the browser, then step straight into the server function and back, as one program. A beginner does not yet hold "client" and "server" as separate worlds. With this, the boundary is not there.
05The tutorial system
You learn Au in the browser, with nothing to install. The course is Introduction to Programming with Au. It is fully interactive: over 100,000 words across 18 modules, with more than 50 quizzes, over 1,000 questions, and more than 100 exercises. No prior programming knowledge is required.
You read a lesson and run real Au beside it, on the same screen. You do not swap windows or pause a video. You edit the code and debug it there in the tutorial. The lessons carry three kinds of note. A Class Note explains the idea. A Tutor Note guides the teacher. A Developer Note gives the words a professional would use.
Most people learn Au in about two weeks. What happens next is a developer journey of its own.
06Catalyst
Catalyst is where a developer learns Au and builds a profile worth showing. It tracks module and quiz progress, and real coding stats — compiles, runs, and debug sessions. It shows the projects the developer has built, each one runnable with its code behind it. A built-in job portal connects developers with the people who need their skills.
"I thought they were kidding when they said you could learn to code in Au in two weeks. They weren't."
07Training and the developer journeys
Aucoda does not hire experienced developers. It takes on graduates in their first job and undergraduates on a placement year, and teaches them Au. The full course runs in two weeks. After it, a new developer joins a project team beside experienced Au developers and starts to code. Within a few weeks the questions stop, and the work is real.
The pathway does not end at a first job. A developer is given real projects to build, can become an Au Ambassador and mentor others, and keeps a portfolio and a Catalyst profile to show for it. Many placement students go back to university, use Au for their final-year project, and graduate with a First.
Four of those journeys, in their own words:
08What made it unusual
Declarative interface, on every platform
Au described screens declaratively around 2015, before Apple shipped SwiftUI. You write the layout and the style once. The same appearance block becomes CSS on the web and Auto Layout on iOS. One description, each platform's own mechanism underneath.
One keyword erases the client and server split
A webfunction reads like any other function. The interface runs in the browser, the logic runs on the server, and the developer does not wire the two together. The compiler does that work.
One designer, then the people it trained
Raj Curwen designed the language and built the compiler alone. The Automic IDE around it was then built by Ashleigh, a graduate who had learned Au in two weeks. The tool was built by the kind of developer it was made for.
09A short history of Aucoda
Au comes from one person. Dr Raj Curwen — formerly at ICI and ABB, with a PhD from Loughborough under Professor James Alty — invented the language and built the compiler. Aucoda is the company around it, in Manchester. Au grew over a decade, and Au Academy opened in 2015.
From 2016, Aucoda stopped hiring experienced staff. Instead it took on graduates in their first job and undergraduates on a placement year, taught them Au in two weeks, and built its teams from them. Those developers then shipped Au in production.
The work reached real institutions. Au built and delivered systems for these organisations and more:
10Where the work goes now
Au was never really about the language. It was about thinking differently — about how a team approaches recruitment, development and training. Empower youth. Specialise your outputs. Hire developers with the right skills for the job, at any time.
The idea under Au outlasts the language. A deterministic layer that constrains and checks a creative one is what the current wave of AI needs. The model imagines. Something underneath has to say no. Au was that layer for a person writing code. The same instinct — take a hard computer-science idea and make it work in production — shapes the work that followed Aucoda.
Au was not the first language either. That was Viper, an agent language built in 1994 that anticipated much of today's AI agent stack.