GitHub - Zaneham/jovial-compiler: A compiler for the Jovial Language

JOVIAL J73 Compiler

A fully functional native compiler for JOVIAL J73 (MIL-STD-1589C), a programming language from 1959 designed for bombing things more accurately. Now you too can experience the joy of military avionics software development from your gaming PC.

What is JOVIAL?

JOVIAL (Jules' Own Version of the International Algebraic Language) was created in 1959 because apparently FORTRAN wasn't violent enough. It was used extensively in:

• F-16 Fighting Falcon flight control systems
• B-2 Spirit stealth bomber
• Various missiles (the ones that find you)
• Other things the government won't tell us about

It's basically what happens when the Pentagon asks "what if ALGOL, but angrier?"

Features

This compiler goes harder than it has any right to:

• Native Code Generation - Compiles to actual x86-64 machine code via LLVM. Not interpreted. Not transpiled. Real electrons doing real work.
• C Transpiler - For when you need to see what cursed code you've written in a language humans can read
• Full J73 Support - Variables, procedures, tables, STATUS enums, the whole military-industrial complex
• I/O - PRINT and READ because even fighter jets need to say hello sometimes
• LSP Integration - Yes, there's a Language Server. Yes, you can get IntelliSense for a language older than the moon landing.

Installation

Option 1: Download Prebuilt Binaries (Recommended)

Grab a release from the Releases page. Unzip. Run. Pretend it's 1959.

Option 2: Build From Source

For those who enjoy suffering:

# Clone this bad boy
git clone https://github.com/Zaneham/jovial

# Download LLVM 18 and tell Rust where it is
export LLVM_SYS_180_PREFIX=/path/to/llvm

# Build it
cargo build --release

# Question your life choices

Requirements (for building)

• Rust (latest stable)
• LLVM 18 (set LLVM_SYS_180_PREFIX to your LLVM installation)
• A deep appreciation for military history
• Questionable decision-making skills

Usage

# The easy way - compile straight to executable
jovialc myprogram.jov -f exe

# Run your 1959-era code at 2025 speeds
./myprogram

# Or specify an output name
jovialc myprogram.jov -f exe -o bomber.exe

Output Formats

Hello World

START HELLO;

PRINT('Hello from 1959!');

TERM

Yes, TERM instead of END. Yes, strings use single quotes. Yes, semicolons everywhere. Welcome to the past.

Fibonacci (Because We Must)

START FIBONACCI;

ITEM N S 32 = 10;
ITEM A S 32 = 0;
ITEM B S 32 = 1;
ITEM TEMP S 32 = 0;
ITEM I S 32 = 0;

PRINT('Fibonacci sequence:');

WHILE I < N;
    PRINT(A);
    TEMP := A + B;
    A := B;
    B := TEMP;
    I := I + 1;
END

TERM

Output:

Fibonacci sequence:
0
1
1
2
3
5
8
13
21
34

It runs. On your modern computer. In native code. A language designed when computers were the size of rooms is now printing Fibonacci numbers faster than the original programmers could blink.

Fun Facts

• JOVIAL was standardised as MIL-STD-1589. There have been multiple revisions. People cared about this.
• The language uses ' in identifiers like CURRENT'WAYPOINT. This is called an "apostrophe identifier" and it's exactly as cursed as it sounds.
• Arrays use 1-based indexing AND parentheses for access. WAYPOINTS(5) is array access, not a function call. The parser just has to figure it out.
• There are people alive today who wrote production JOVIAL code. Some of them are probably on LinkedIn.

Why Does This Exist?

1. Preservation of computing history
2. A deep and concerning interest in military aviation software
3. To prove it could be done
4. I wasn't going to play video games anyway (lie)
5. Someone, somewhere, might have legacy JOVIAL code they need to compile
6. The LSP was already done and needed a friend

Technical Details (For The Brave)

┌─────────────────────────────────────────────────────────────┐
│                    JOVIAL J73 Compiler                      │
├─────────────────────────────────────────────────────────────┤
│  Source (.jov)                                              │
│       ↓                                                     │
│  Lexer (Logos) → Tokens                                     │
│       ↓                                                     │
│  Parser (Recursive Descent) → AST                           │
│       ↓                                                     │
│  Semantic Analysis → Symbol Table, Type Checking            │
│       ↓                                                     │
│  LLVM Codegen (inkwell) → LLVM IR                          │
│       ↓                                                     │
│  LLVM Backend → Native Object File                          │
│       ↓                                                     │
│  Linker → Executable                                        │
│       ↓                                                     │
│  Your code runs on silicon that would blow the minds        │
│  of every engineer who worked on the original compilers     │
└─────────────────────────────────────────────────────────────┘

Related Projects

If you've made it this far, you're clearly interested in languages that predate common sense. Good news: there's more where this came from.

The Vintage LSP Collection

Because syntax highlighting is a human right, even for languages the Geneva Convention forgot:

The Emulator Menagerie

When compilers aren't enough and you need to simulate entire extinct and new computers:

Other Sins Against Modern Computing

• Plankalkuel - An interpreter for the world's first programming language (1948). Yes, before FORTRAN. Yes, it works.
• chill-compiler - Because one vintage compiler wasn't enough
• SLATEC.jl - Mathematical libraries from the 70s, now in Julia
• z390Zane - Mainframe assembler and emulator. For the full experience.

If you're seeing a pattern here, congratulations. You've identified a problem.

Contact

Found a bug? Want to discuss the finer points of MIL-STD-1589C? Simply need to tell another human being that you write JOVIAL and have them not immediately change the subject?

zanehambly@gmail.com

I can't promise I'll fix your problem, but I can promise I'll be unreasonably interested in it. If you're maintaining legacy avionics code and need moral support, I'm your man. If you're from the Pentagon and this compiler somehow ended up in something important, I would like to state for the record that I included a test suite.

Based in New Zealand, where it's already tomorrow and the sheep outnumber the JOVIAL programmers roughly eight million to one.

License

BSL-1.0 (Business Source License)

Basically: do whatever you want, just don't compete with me selling JOVIAL compilers. Converts to Apache 2.0 in 2029.

Free for Ukraine

Remember earlier where I mentioned F-16s run JOVIAL? Ukraine has F-16s now.

This compiler includes a perpetual, royalty-free license grant for:

• The Armed Forces of Ukraine (Zbroini Syly Ukrainy)
• The Ministry of Defence of Ukraine
• Anyone maintaining, repairing, or operating military equipment in service of Ukraine
• Ukrainian educational institutions providing related training

Commercial JOVIAL compilers cost more than a new car and come with export control headaches that would make a lawyer cry. If some Ukrainian engineer needs to patch flight control software at 3am and this compiler helps, then the mass of cursed military computing knowledge in my head will have done something useful.

If you're working on Ukrainian defence systems and need help, reach out. I can't promise I'll be useful, but I can promise I'll try.

Acknowledgments

• The US Department of Defense, for creating this beautiful mess
• LLVM, for making this possible without hand-writing x86 assembly
• Rust, for making me feel safe while doing deeply unsafe things
• The youtuber Low Level for his course on Rust which helped me learn the language a bit. You can check out his youtube here: https://www.youtube.com/@LowLevelTV
• You, for reading this far. You're my kind of weird.

Built with love, confusion, and far too much coffee in Aotearoa New Zealand.

"She'll be right, mate." - Every engineer who ever deployed JOVIAL code to a fighter jet, probably