Learn how to program games with the LÖVE framework

Chapter 4 - LÖVE

What is LÖVE?

LÖVE is what we call a framework. Simply said: It's a tool that makes programming games easier.

LÖVE is made with C++ and OpenGL, which are both considered to be very difficult. The source code of LÖVE is very complex. But all this complex code makes creating a game a lot easier for us.

For example, with love.graphics.ellipse(), we can draw an ellipse. This is the source code behind it:

void Graphics::ellipse(DrawMode mode, float x, float y, float a, float b, int points)
    float two_pi = static_cast<float>(LOVE_M_PI * 2);
    if (points <= 0) points = 1;
    float angle_shift = (two_pi / points);
    float phi = .0f;

    float *coords = new float[2 * (points + 1)];
    for (int i = 0; i < points; ++i, phi += angle_shift)
        coords[2*i+0] = x + a * cosf(phi);
        coords[2*i+1] = y + b * sinf(phi);

    coords[2*points+0] = coords[0];
    coords[2*points+1] = coords[1];

    polygon(mode, coords, (points + 1) * 2);

    delete[] coords;

You might not understand this code above at all (I barely do so myself), and that's exactly why we use LÖVE. It takes care of the hard parts of programming a game, and leaves the fun part for us.


Lua is the programming language that LÖVE uses. Lua is a programming language on its own, and is not made by or for LÖVE. The creators of LÖVE simply chose Lua as the language for their framework.

So what part of what we code is LÖVE, and what is Lua? Very simple: Everything starting with love. is part of the LÖVE framework. Everything else is Lua.

These are functions part of the LÖVE framework:

love.graphics.circle("fill", 10, 10, 100, 25)
love.graphics.rectangle("line", 200, 30, 120, 100)

And this is simply Lua:

function test(a, b)
    return a + b
print(test(10, 20))
--Output: 30

If it's still confusing to you, that's okay. It's not the most important thing right now.

How does LÖVE work?

You're required to have LÖVE installed at this point. Go back to Chapter 1 if you haven't already.

LÖVE calls 3 functions. First it calls love.load(). In here we create our variables.

After that it calls love.update() and love.draw(), repeatedly in that order.

So: love.load -> love.update -> love.draw -> love.update -> love.draw -> love.update, etc.

Behind the scenes, LÖVE calls these functions, and we to create them, and fill them with code. This is what we call a callback.

LÖVE is made out of modules, love.graphics, love.audio, love.filesystem. There are about 15 modules, and each module focuses on 1 thing. Everything that you draw is done with love.graphics. And anything with sound is done with love.audio.

For now, let's focus on love.graphics.

LÖVE has a wiki with an explanation for every function. Let's say we want to draw a rectangle. On the wiki we go to love.graphics, and on the page we search for "rectangle". There we find love.graphics.rectangle.

This page tells us what this function does and what arguments it needs. The first argument is mode, and needs to be of the type DrawMode. We can click on DrawMode to get more info about this type.

DrawMode is a string that is either "fill" or "line", and controls how shapes are drawn.

All following arguments are numbers.

So if we want to draw a filled rectangle, we can do the following:

function love.draw()
    love.graphics.rectangle("fill", 100, 200, 50, 80)

Now when you run the game, you'll see a filled rectangle.

The functions that LÖVE provides is what we call the API. API stands for Application Programming Interface. You can read the Wikipedia article to learn what an API exactly is, but in this case it simply means the LÖVE functions you can use.


LÖVE is a tool that makes it easier for us to make games. LÖVE uses a programming language called Lua. Everything starting with love. is part of the LÖVE framework. The wiki tells us everything we need to know about how to use LÖVE.

Do you need help or do you see a mistake?
Leave a comment or edit this chapter.