Getting Started

A Raylib program owns its main loop. This explicit structure makes it easy to see what happens once and what happens during every frame.

Table of Contents

  1. Your Course Project
  2. A Minimal Raylib Program
  3. The Program Lifecycle
  4. Clearing and Presenting a Frame
  5. Window Dimensions
  6. Frames and Time
  7. Cleanup Order

Your Course Project

Use the Raylib quick start project to set up your game:

  1. Clone the repository.
  2. Rename the cloned folder to your game name.
  3. Rename src\main.c to src\main.cpp
  4. Run build-VisualStudio2026.bat in that folder.
  5. Double-click the generated .slnx file to open the project in Visual Studio.
  6. Starting developing your project by editing the main .cpp file, building it, and running it.

A Minimal Raylib Program

Replace the contents of the project’s main .cpp file with this complete program:

#include "raylib.h"

int main() {
    constexpr int screenWidth{800};
    constexpr int screenHeight{450};

    InitWindow(screenWidth, screenHeight, "Hello, Raylib!");
    SetTargetFPS(60);

    while (!WindowShouldClose()) {
        // Update variables and respond to input here.

        BeginDrawing();
        ClearBackground(RAYWHITE);

        DrawText("Hello, Raylib!", 290, 210, 24, DARKBLUE);

        EndDrawing();
    }

    CloseWindow();
    return 0;
}

The program should open an 800 by 450 pixel window. It keeps drawing until you press Escape or click the window’s close button.

The Program Lifecycle

Most introductory Raylib programs have four stages:

  1. Initialization happens once. Create the window, configure the target frame rate, initialize audio when needed, and load resources here.
  2. Update and input happen once per frame. Read the keyboard or mouse, move objects, test collisions, and change stored state here.
  3. Drawing happens once per frame between BeginDrawing() and EndDrawing().
  4. Cleanup happens once, after the loop. Unload resources and close the systems that created them.

WindowShouldClose() returns true when Raylib receives a close request. The ! means “not,” so the loop continues while the window should not close.

⚡ Keep the pair together:

Every call to BeginDrawing() must have one matching EndDrawing() in the same frame. Put drawing calls between them.

Clearing and Presenting a Frame

BeginDrawing() prepares Raylib to draw the next frame. ClearBackground() fills the entire window with one colour so pixels from the old frame do not remain. EndDrawing() finishes the frame and presents it in the window.

Unlike a framework with predefined callback methods, Raylib does not call your update() or draw() functions. The comments in the example mark conceptual sections of the loop. As a program grows, you may choose to move those sections into your own functions.

Window Dimensions

The constants passed to InitWindow() set the initial client-area dimensions in pixels. You can ask for the current dimensions later:

const int currentWidth{GetScreenWidth()};
const int currentHeight{GetScreenHeight()};

This is useful if the window may be resized. For a resizable window, call SetConfigFlags(FLAG_WINDOW_RESIZABLE) before InitWindow().

Frames and Time

SetTargetFPS(60) asks Raylib to limit the program to approximately 60 frames per second. It is a target, not a promise: a slow computer or expensive frame can take longer.

Raylib provides several useful timing functions:

const int framesPerSecond{GetFPS()};
const float deltaTime{GetFrameTime()}; // Seconds taken by the previous frame.
const double elapsedTime{GetTime()};   // Seconds since InitWindow().

GetFrameTime() is often called delta time. We will multiply movement speed by delta time so an object moves approximately the same distance per second on fast and slow computers.

GetTime() is useful for repeating animation such as a pulsing radius:

#include <cmath> // Place this with the other includes, above main().

const float radius{30.0F + 8.0F * static_cast<float>(std::sin(GetTime() * 3.0))};
DrawCircle(GetScreenWidth() / 2, GetScreenHeight() / 2, radius, SKYBLUE);

Cleanup Order

CloseWindow() releases the window and graphics context. Any resource that depends on that graphics context, such as a texture, font, or render texture, must be unloaded before CloseWindow().

A useful rule is: clean up in the reverse order that you initialized and loaded things.

Resources