Lesson finished
Up next: Basic Linux Commands, Building OpenFOAM and Setting Up WSL
Unlock all 49 lessons of Introduction to OpenFOAM DevelopmentFull course ₹40,000 · paid
Running OpenFOAM on Windows and Linux, and Why Learn It
A free lesson from Skill-Lync's Introduction to OpenFOAM Development course, on Grow by Skill-Lync · Last updated 16 Nov 2026 · Session: “Installing and Using OpenFOAM on Different Operating Systems”
What will you learn in this free Introduction to OpenFOAM Development lesson?
The instructor explains that OpenFOAM compiles natively on Linux, so Windows users need an interface, and recommends Windows Subsystem for Linux over Docker, virtual machines or MinGW. The lesson then shows a transport equation written as solver code and closes with the strengths of OpenFOAM, such as its GNU license, free source code and wide use.
- Why WSL is recommended for OpenFOAM on Windows
- Docker containers versus virtual machines
- Transport equation terms: ddt, div and laplacian
- Why OpenFOAM suits learning how equations become code
What comes after lesson 2?
The next free lesson is lesson 3, “Basic Linux Commands, Building OpenFOAM and Setting Up WSL” (16 min). Later in Skill-Lync's Introduction to OpenFOAM Development course (paid): lesson 4, OpenFOAM Case Structure and Compilation; lesson 5, Setting Up Development Environment and Debugging in OpenFOAM; lesson 6, Introduction to Visual Studio Code for OpenFOAM Development. The full course has 49 lessons (18 h 16 min of video); see the course overview or its price and syllabus.
Lesson transcript
Machine transcript of the lesson audio (lightly cleaned). Technical terms may contain errors; the video is the reference.
Hi, everyone, and welcome back to session two. In continuation of what we discussed in the last session, I will repeat that I will be discussing the ESI OpenCFD version, unless specified otherwise. At the start of the course, I mentioned that you will probably have to have some experience with working natively on Linux environments, because OpenFORM compiles natively on Linux environments. That means that OpenFORM will not directly work as a binary on your Windows system. You will have to have an interface. Now, it can be any form of interface. There are multiple workarounds that have been presented for OpenFORM.
I personally use OpenFORM on my Windows 10 system, so I don't... I used to use it on my dedicated Ubuntu operating system, but then I discovered something called the Windows Subsystem for Linux. So, Windows Subsystem for Linux is basically like a virtual machine that operates on your system, but it doesn't have any of the overhead that a virtual machine has. So, it runs pretty fast. It runs like a terminal. We'll be looking at what OpenFORM version can be installed on what operating system and how, so you don't have to worry about it.
So, my recommendation, as I said, is to go around with the Windows Subsystem for Linux. Linux binary installations can be done either via Docker or via RPM if you have OpenSource. So, again, if you're not familiar with the name OpenSource, there is Linux, which is an operating system which has multiple distributions. It could be Red Hat, Ubuntu, or OpenSource. So, certain ways of installing on certain distributions are different from the others. So, you'll have to be sure that we are going to be using Ubuntu for our installation.
So, I recommend that you Google these terms if you haven't heard them already because these are very vital for a CFD engineer because if you're a CFD engineer, you will be working with terminals and you will be working with Linux environments because clusters or high-performance computing is mainly done on a Linux operating background. So, you'll have to know these things. For example, Docker is something that's relatively new, but it's a form of containerized applications. So, you can basically have an entire container of a Linux operating system, and that container can be transported anywhere.
For example, if you have a Windows OS that you want to run it in, that container will work without any overhead. So, that is what distinguishes it from a virtual machine. A virtual machine has a lot of overhead. If you've tried using virtual machines before, you know that they take a lot of time to start. They occupy a lot of memory. But Docker systems are fully functional, and they do not have the overhead of a virtual machine. I'm presenting alternatives to you in case you want to use Openform differently.
You can natively not install Openform in Windows, as I said before, but there are, again, for example, a Docker version. Just like I've shown here, you can install Openform here. This can be Openform, and then it will work on your Linux OS, and since the Docker works on your Windows, it will work perfectly. Or, of course, you can do a virtual machine installation as well. There are MinGW versions, which are just minimal Linux environments that are present. So, you will probably get a terminal that is very similar to what you see on Linux systems, but then that is a bash terminal that is configured for Windows.
So, it has the basic functionalities that Linux has, but then that's it. I don't recommend you do any of this. I recommend very strongly that you just get Windows subsystem for Linux. All this will be available when you see how you can build it. Most of the Openform documents that you see are build guides, which means that they're compiling some code from source. That means you're not installing it as a binary. You're not installing it as an EXE, as you would think of in Windows. You're actually compiling the code from scratch.
You're just getting the source code. You're pulling the source code from somewhere. This will probably be from the website, and you're doing system checks, and you're compiling Openform on your system. This is also the version that I use to compile and make Openform. Moving on. So, we've learned a lot of theory. I'm assuming you've learned a lot of theory about fluid mechanics in your undergraduate courses or in your graduate courses. You want to translate this into code. What a lot of undergraduates experience is that their professors usually have their own code or a code that's compiled just for the purpose of that class.
And it's a very simple code. You'll probably have a simple Cartesian grid, which will solve a Poisson equation, etc. And you'll probably see a simple driven cavity problem at the end of the course. But the problem with that is you're never actually progressing past a certain point. You're stuck with the simple stuff, but then you never actually get to the more complicated, the things that you actually encounter in non-academic situations. You never get to it. So, that is the good thing about Openform. You can represent equations as solver code.
It's very easy and it's a very simple translation. It's easy to see directly how your code translates into equations. There are a lot of solvers that are present in Openform. We discussed some of them start with the basic ones. Laplace and potential flow. So, this is what you would see if you're trying to initialize a flow. So, if you want to... The potential flow basically solves the potential equations. You can Google this. We can discuss this later. Or the Laplace solver basically just is a Laplacian form, which is just solving the Laplacian equation or a diffusion equation.
There are a vast range of solvers in this category. But the biggest category, the one that you'll most likely encounter, is either incompressible or compressible flow solvers. So, anywhere from your simple form, which would be a steady state. So, it's steady and it's incompressible. This is the most commonly used solver that you have, that you'd use for, let's say, external aerodynamics calculation. But you could also have another case, which is rho-pimple form. So, as you can see, rho before it, rho usually means density. Change in density usually signifies a compressible flow problem.
So, this definitely means unsteady or transient and compressible. And in this range, there are a lot of solvers. You can have rho-simple form. You can have pimple form just on its own. Piece of form, etc. A range of solvers are present here. Let's look at multiphase. It's very often the case that you don't actually have just one phase of fluid in your simulation. You want to simulate multiple fluids together. You want to simulate, let's say, bubbles, etc. These bubbles are a typical example of air within a fluid that is a multiphase flow.
So, you'll have many strategies to deal with this. Euler is one of them. Or volume of fluid is one of them. Volume of fluid is something, or VOF, as it's colloquially called, is something that you'll encounter a lot. But it basically maps an interface between two fluids, and then it models them that way. Of course, we won't go into detail in too much detail about all this. It's not required. And it's beyond the scope of this course. But we look at other things as well. For example, Lagrangian solvers are very common in companies that have, or organizations that simulate spray, simulate combustion, because you need to have spray particles that are moving at a Lagrangian frame of reference.
So, these particles are moving, whereas your mesh is stationary, in most cases. So, you need to have different forms of solvers that deal with this kind of problem. Lastly, but not the least, of course, you have a lot of solvers. Lastly, you have heat transfer problems. So, in many cases, you also want to model heat transfer between two fluids, or between a fluid and a solid. In that case, you have a CHD problem, which is a conjugate heat transfer. So, as I promised you, it is really simple to code transport equations, or any form of equation, and see it in code.
At least for the simpler ones. Of course, it gets more difficult in general. In general, you have, let's say, a transport equation that looks like this. This transport equation could be anything. For example, in this case, it could be the transport of temperature. So, this is the time transport, or how it changes along time. So, the unsteady term, so to say. This is the advection, or some call it convection. And I apologize for my handwriting at the start, and this would be the diffusion. So, any scalar transport equation, as I've mentioned here, any scalar transport equation basically has these components.
It has something that's evolving in time, and then something that's moving along, advecting or convecting, and it has something that's diffusing it. It's something that's taking away the amplitude of this quantity. Very easy to show in open form. You can just show it by means of, let's say, a simple solve function. So, this ddtt is the same thing as the first term. Divergence is the divergence operator, which is basically this. Phi, don't get confused here, because this is phi. As you can see, phi is basically a flux component of whatever you want to advect.
So, in this case, phi would. The flux version of the velocity U. And then you have Laplacian. Laplacian is again the diffusion term that is applied to temperature DT here being the coefficient D. So it's this coefficient that is applied to the Laplacian. So the aim of this introductory lecture was to introduce all of you to OpenForm and generate some interest for it. I know it's difficult moving to a completely new format of learning how to code and how to develop software for computational fluid dynamics.
But trust me, as you move to OpenForm, at least as part of your academia, there will be a lot you learn. And there are a lot of strong points which we are going to touch into. So the first bit is all versions of OpenForm are covered by a GNU public license, which means you can contribute to all these versions. That means you can actually be a contributor to all versions that we have discussed so far. You can submit code, it will undergo a review process, and maybe it's in the new release of OpenForm.
So it's that easy. The general advantage with any free and open source software is, of course, it's at no cost. So you don't have to pay expensive license fees to use the software. It's ideal for learning. If you want to actually look behind the black box that most CFD softwares are, you can actually do that. You can actually look at the source code and see for yourself and modify things. One thing that particularly strikes me is that OpenForm covers a wide breadth of physical problems. So it's not restricted to flow, single-phase flow, multi-phase flow.
It has a wide, wide range of things it can do. In fact, it's community-driven, so it can also introduce new things. For example, I believe there is also a solver that models financial markets. It sometimes doesn't have anything to do with CFD at all. That can be modeled as well. Any partial differential equation can essentially be modeled in the OpenForm interface. As I said, FormExtend also managed to model solid mechanics problems, structural problems. So you can migrate your entire workflow to OpenForm and you'll probably be okay.
The good thing about OpenForm, since it's free and open source, it allows modifications to the code and also allows quick replication. So you can quickly implement new models in your code and you can quickly copy a solver and have a new one and you can make changes to the solver and call it your own solver. You know, that helps a lot when you're learning because you want to see quick changes, incremental but quick changes. One thing that draws me to it a lot is that it has very active development.
So there are a lot of people working on OpenForm currently, so you see a lot of changes that are implemented. For example, if you saw the release notes, you saw a dedicated team of people is working on this particular version of OpenForm to release new features every year. And the community version has a lot of contributors as well. Yeah. So a lot of people are working on it. You'll always find support when you need it. The good thing is, if you have any questions, there is this very wonderful website called CFD Online.
So CFD Online has forums where you can ask questions about anything that you have. So this has anything to do with development questions or just usage questions. You can always ask questions on it. So post-processing, running, solving, CFD, everything under the sun, you have something that you can actually ask questions about and you can get quick answers to. So I recommend, if there's anything during your installation you don't understand, look at this. Just post a question on the forum. Some unique advantages is that it's an industry leader in some areas.
For example, viscoelastic models is something that I've been acquainted with. And there are research groups that do things in OpenForm that are not present in any other solver. There are, of course, academic codes that are only restricted to the particular research group that you're a part of. But OpenForm is worldwide. So there are a lot of people using OpenForm. And hence, it's a big strong point. OpenForm has a certain state of the art. There is things that they're developing in that particular year. I just thought I'd highlight some things that are interesting from this year's release.
That is, the 2006 version. For example, they were doing something that I really like about adjoint methods. Adjoint methods are a form of continuous differentiation. That is, they use your flow field to give you inputs on how you should change your geometry. For example, in this case, adjoint would give you sensitivities on your entire domain. It would tell you, hey, this mirror should be curved in this way. It should probably have an edge that's smaller, which will give it a lower drag coefficient or whatever. In this case, there were new developments brought to this tool this year.
From what I've read, I think you can specify boxes where that development should happen. So these developments keep happening every year and without fail. So this is one example of a new thing that's happened in the new release. Something that I've also been acquainted with is aeroacoustics. So this is a field, if people are interested, aeroacoustics. I apologize for my handwriting once again. Aeroacoustics is basically the phenomena of noise produced due to fluids, due to fluid flow, and due to turbulence. This is very important, especially in the cars of today.
Because let's say if you have an electric vehicle, the noise generated by all other components of the electric vehicle are going to be very low. So the major bottleneck for your noise is going to be from your moving body. It's going to be from how your fluid, how the air interacts with your car, and what turbulence generated noise there is. For example, in this case, a simple flow around a cylinder is shown. There are a lot of ways to measure the far field acoustic pressure, for example.
There are a lot of models to do it. So, for example, in this case, the curl function object has been refactored. You can do a lot of new things in computing the acoustic pressure. So that was one of the new changes that came about in this release of OpenFOAM. These are just examples just to generate some interest and to introduce some new research fields that you guys should look into. Moving on. Something that I've written about before as well. The good thing about OpenFOAM is it has a very good coupling tool that allows it to couple with a lot of other solvers that are present.
It's called Precise. So what Precise does is it is like a coupling library for multiphysics simulation. So it will basically map and communicate all your fluid flow data with, for example, with your structure data. For example, if you get any of these solvers, these are all structure solvers. So you get structural solutions. For example, the stresses that are obtained. You can couple that and basically have an FSI problem. That is a fluid structure interaction problem. A fluid structure interaction problem or a CHD problem, a conjugate heat transfer problem.
So if you want to look at how the flow around an airfoil bends it or causes it to flutter, for example, that is an FSI problem. And these kind of problems can be done very well with the help of a library called Precise. It is to note that you will need some sort of a coupler. So this basically means that there is a coupling or a coupler between your open form solver and your Precise. So you'll have to install this. You'll have to install Precise. And you'll have to install a coupler that couples the structure solver to your Precise.
So you need to have an open form to Precise coupler, a Precise to structure coupler, etc. But this makes it very handy and very robust because you can do computations with a range of other solvers and you can couple your results with a range of other solvers, which makes it really interesting. We'll be looking at who the power users of open form are and why you should be learning it. This is not keeping you very restricted. This is based out of my experience, which companies work in open form or which organizations work in open form.
But there are a range of worldwide power users. Open form has a widespread use in academia. The universities that I've mentioned here, WTH Aachen, TU Munich, KIT, TU Delft, Virginia Tech, etc., etc. So these are groups that I personally know that work on open form. A university in Sweden does a lot of work. Chalmers in Sweden, for example, is very, very involved with open form. So if you guys have plans to do your master's in Sweden or in Europe or anywhere in the world, there are always people somewhere that are working on open form development.
For example, the Precise Coupling that I've shown you before, the open form Precise Coupling comes out of TU Munich. So they are the ones working on that. There's also this stereotype that open form is mainly for academic use. That's not true. I've personally worked on open form in industry. Especially in Europe, this is the case that open form is very widely used within some companies. For example, the Volkswagen Group. The Volkswagen Group has a lot of daughter companies. This could be Volkswagen AG, Audi, Porsche, or Mann.
All these companies form part of the Volkswagen Group and they naturally do a lot of CFD simulation. All these companies use a lot of it. The chemical industry in Germany as well as all around Europe are very, very reliant on open form. A lot of these companies are. Of course, if you want to look at your future as part of your own undergraduate studies or when you plan to do your master's or your PhD program, if you want to do any of these student team, if you want to participate in any student team competition, or in fact, there are also solar car teams that very definitely rely on open form because it's open source.
It's very difficult for them to obtain licensing sometimes. So, they end up using open form very, very frequently. So, this would be a very big differentiator for you if you end up applying to a team or student organization. There are a lot of startups that base a solution on open form. For example, SimScale is one I'm very well acquainted with. SimScale generally provides a cloud-based solution for Openform, that is, they use Openform on their back-end, and they try to build a solution based, try to give you a GUI based on your solution with Openform.
Of course, an important question is, why should you learn Openform? In my opinion, it allows you to learn theoretical aspects with your code better than any other software that you'd probably learn. use as part of your education. So, again, learning and understanding how code works and how it translates from the equation that you've learned is a prerequisite to clearing any CFD interview. So, if you want to be a CFD engineer anywhere, it's a prerequisite. You need to know how the equations work and how they translate into code. That can be very well done with Openform.
Of course, the other option is for you to write your own code, but as I said before, that doesn't usually translate well into very complex cases. I've mentioned before that there is a thriving CFD community online, CFD online. So, if you have any questions and any problems that you might face, they are usually very quick to answer. So, it's always a good idea to check out that forum online. Again, a subsidiary outcome is that it's a very good way to learn advanced C++. For example, templates, polymorphism, MPI programming, these things are good in theory, but learning them with the aid of a tool that is a software is always a better idea.
So, you'll probably end up learning C++ along the way as well. And of course, it's an object-oriented approach, so that will help you strengthen some concepts on how classes, constructors, objects work, and how you can use them in a CFD tool. That's it from me. We'll see each other in our next session. Thank you so much. Bye.