Simula Programming Language: Origins, Uses & Examples

Every modern programming language you use today owes something to Simula. Sounds like a big claim, right? But it’s true.

Most people studying computer science or software development have never even heard of Simula. And honestly, that’s a bit of a shame — because without it, there’s a good chance Java, C++, and Python wouldn’t look anything like they do today.

So what exactly is the Simula programming language? In simple terms, it was the world’s first object-oriented programming language. It was built back in the 1960s by two Norwegian computer scientists, and it introduced ideas like classes, objects, and inheritance — concepts that pretty much every developer uses on a daily basis now.

In this blog, we’ll walk through the full story — where Simula came from, how it works, some real examples, and what it was actually used for. Let’s get into it.

What Is the Simula Programming Language?

Simula stands for Simulation Language — pretty straightforward name, right? It was created in the 1960s by two Norwegian computer scientists, Ole-Johan Dahl and Kristen Nygaard, and it’s widely recognized as the world’s first object-oriented programming language. That’s not a small thing.

Now, Simula actually came in two versions. The first one, Simula I, was released in 1962 and was mostly built for running simulations. Then came Simula 67 in 1967 — this was the bigger deal. It evolved into a general-purpose language and introduced the ideas that actually shaped modern programming.

It was built on top of ALGOL 60, which was a popular language at the time. But Dahl and Nygaard took it much further by adding classes, objects, inheritance, and coroutines — the core building blocks of OOP that developers still rely on today.

Simula Programming Language History

To really understand Simula, you’ve got to go back to early 1960s Norway.

Ole-Johan Dahl and Kristen Nygaard were working at the Norwegian Computing Centre (NCC) in Oslo. They needed a way to simulate complex real-world systems through code — things like traffic flow, queues, and networks. So between 1962 and 1967, they built Simula specifically for discrete event simulation.

The first version, Simula I (1962), was essentially an extension of ALGOL 60. It worked around two main ideas — “stations” and “customers” — which were used to model event-based networks. Useful, but limited.

Then came Simula 67, and that’s where everything changed. It introduced classes, subclasses, and virtual procedures — turning Simula into a proper general-purpose language.

But it never really took off commercially. Bjarne Stroustrup, the creator of C++, actually used Simula early on but found it too slow for practical work — so he went ahead and built C++ instead.

Still, Simula’s DNA lives on. Java, C++, Python’s OOP features — they all trace back to ideas that Dahl and Nygaard figured out decades ago.

Core Features of the Simula Programming Language

So what actually made Simula so revolutionary? Let’s break down the key features that set it apart — and honestly, most of these will look very familiar to you.

1. Classes and Objects: This was Simula’s biggest contribution. It let you create a “class” as a blueprint and then build objects from it — just like you do in Java or C++ today. Completely new idea at the time.

2. Inheritance: Simula allowed one class to inherit properties from another. So you could build on existing code without rewriting everything from scratch. Sounds obvious now, but in the 1960s, this was groundbreaking.

3. Encapsulation: Data and the functions that work on it were kept together inside a class. Clean, organized, and much easier to manage.

4. Coroutines: This one’s a bit more technical. Coroutines allowed multiple processes to run in a controlled, interleaved way — super useful for simulations.

5. Virtual Procedures: Introduced in Simula 67, these allowed subclasses to override methods from a parent class — the foundation of what we now call polymorphism.

Note: If you’re interested in exploring other unique programming languages, check out our detailed guide on the Zero Programming Language as well.

Simula Programming Language Examples

Don’t worry — we’ll keep it simple and explain what’s happening at each step.

Example 1: Defining a Simple Class 

Class Car; Begin    Text Model;    Integer Speed;    Procedure ShowDetails;    Begin       OutText(“Model: “);       OutText(Model);       OutInt(Speed, 5);       OutImage;    End; End;

This is basically a blueprint for a Car. It has two pieces of data — a model name and a speed — and one procedure that prints those details. If you’ve written a class in Java before, this will feel very familiar.

Example 2: Creating an Object 

Ref(Car) MyCar; MyCar :- New Car; MyCar.Model :- “Toyota”; MyCar.Speed := 120; MyCar.ShowDetails;

Here we’re creating an actual Car object from that blueprint. We give it a model and speed, then call the procedure to display it. The :- symbol is just how Simula handles object references — think of it like = in modern languages.

Example 3: Inheritance (Subclass Example) 

Car Class ElectricCar; Begin    Integer BatteryLevel;    Procedure ShowBattery;    Begin       OutText(“Battery Level: “);       OutInt(BatteryLevel, 5);       OutImage;    End; End;

Now we’re extending the Car class to create an ElectricCar. It inherits everything from Car and adds its own property — battery level. This is inheritance in action, exactly the same concept you use in Java or C++ today.

What Is the Simula Programming Language Used For?

People often assume Simula was just a research project that never really did anything practical. That’s not quite true. It was actually used for a pretty wide range of things — especially for its time. Let’s break it down.

1. Discrete Event Simulation 

This was the whole reason Simula was built in the first place. It was designed to model real-world systems where events happen one after another — like customers arriving at a bank, ships docking at a port, or patients waiting in a hospital queue. Simula handled this kind of modelling better than anything else available at the time.

2. Scientific and Engineering Simulations 

Researchers used Simula to simulate complex systems in physics, engineering, and other technical fields. It gave scientists a proper programming tool to model things that were too complicated or expensive to test in real life.

3. VLSI Design 

Simula was used in the design of very large-scale integrated circuits — basically the early stages of chip design. That’s a pretty serious real-world application for a language from the 1960s.

4. Process Modelling 

Businesses and researchers used it to model workflows and operational processes — figuring out bottlenecks, optimising systems, that kind of thing.

5. Typesetting and Text Processing 

Interestingly, Simula was also used for typesetting work — formatting and processing documents. Not what you’d immediately think of, but it shows how flexible the language actually was.

6. Early Computer Games 

Yes, really. Some developers used Simula to build early computer games, which just goes to show how general-purpose Simula 67 had become by that point.

7. Academic Research and Teaching 

Simula became a popular language in universities, particularly in Europe. It was used to teach object-oriented concepts long before Java or C++ came along and made OOP mainstream.

Simula’s Influence on Modern Programming Languages

Here’s the thing about Simula — it never became hugely popular on its own, but its ideas quite literally shaped the entire modern programming world. That’s a legacy most languages never get.

C++ 

This is the most direct connection. Bjarne Stroustrup used Simula during his PhD work and loved its class-based structure. When he later built C++, he deliberately brought those same OOP concepts into a faster, more practical language. No Simula, no C++. It’s that simple.

Java 

Java took the class and inheritance model that Simula pioneered and made it accessible to millions of developers worldwide. Every time you write a Java class, you’re using an idea that’s over 60 years old.

Smalltalk 

Alan Kay, the creator of Smalltalk, openly credited Simula as a major inspiration. He took Simula’s object concept and pushed it even further — making everything in the language an object.

Python, C#, and Beyond 

Pretty much every modern OOP language — Python, C#, Ruby, Swift — inherited concepts that trace directly back to Simula 67.

It’s honestly a bit wild when you think about it. Two scientists working in Oslo in the 1960s came up with ideas that billions of lines of modern code are still built on today. Simula didn’t win the race — but it started it.

Simula vs. Other Early Programming Languages

We compared three early programming languages on Google Trends — Simula, ALGOL 60, and Smalltalk — over the past 3 months in the United States. The results are pretty interesting, and honestly a little surprising.

Simula Leads the Search Interest Looking at the chart, Simula (blue line) clearly gets the most search traffic of the three. It spikes regularly — hitting as high as 90 out of 100 at certain points in May. That tells us people are still actively searching for Simula, most likely CS students, developers curious about OOP history, or folks doing academic research.

Smalltalk Holds a Steady Second Place Smalltalk (yellow line) follows behind Simula fairly consistently. It averages around 5 on the interest scale and shows some decent spikes in March and April. It still has an audience — mostly developers interested in early OOP languages.

ALGOL 60 Almost Disappears ALGOL 60 (red line) barely registers on the chart. It had one noticeable spike in April but for the most part sits at near zero. Which makes sense — ALGOL 60 is more of a historical footnote at this point, even though Simula was built on top of it.

What the Average Interest Numbers Tell Us On the right side of the chart, the average interest scores say it all — Simula scores 10, Smalltalk scores 5, and ALGOL 60 scores just 1. Simula is literally 10 times more searched than ALGOL 60 right now.

So What Does This Mean? Even though none of these languages are widely used in production today, Simula programming language is clearly the one people still want to learn about. Its connection to modern OOP languages like Java and C++ keeps it relevant — especially for students studying programming fundamentals and language history.

Conclusion

So there you have it — the full story of the Simula programming language in one place.

It never became the most popular language in the world. It didn’t win any commercial battles. But honestly? It didn’t need to. The ideas it introduced — classes, objects, inheritance, encapsulation — became the foundation that almost every modern programming language is built on today.

If you’re a CS student or a developer, understanding Simula isn’t just a fun history lesson. It actually helps you understand why OOP works the way it does. And that kind of deeper understanding makes you a better programmer.

Simula started something that the entire tech world is still building on. Not bad for a language most people have never heard of.

Frequently Asked Questions (FAQs)