# C API

The goal of the C API is make usage as similar to the original C as CFFI will allow. The example programs are very, very similar to the C originals.

Example program:

    from raylib import *

    InitWindow(800, 450, b"Hello Raylib")
    SetTargetFPS(60)

    camera = ffi.new("struct Camera3D *", [[18.0, 16.0, 18.0], [0.0, 0.0, 0.0], [0.0, 1.0, 0.0], 45.0, 0])
    SetCameraMode(camera[0], CAMERA_ORBITAL)

    while not WindowShouldClose():
        UpdateCamera(camera)
        BeginDrawing()
        ClearBackground(RAYWHITE)
        BeginMode3D(camera[0])
        DrawGrid(20, 1.0)
        EndMode3D()
        DrawText(b"Hellow World", 190, 200, 20, VIOLET)
        EndDrawing()
    CloseWindow()

If you want to be more portable (i.e. same code will work with dynamic bindings) you can prefix the functions like this:

    from raylib import ffi, rl, colors

    rl.InitWindow(800, 450, b"Hello Raylib")
    rl.SetTargetFPS(60)

    ...

See also https://github.com/electronstudio/raylib-python-cffi/blob/master/tests/test_static.py

Note

Whenever you need to convert stuff between C and Python see https://cffi.readthedocs.io

Important

Your primary reference should always be the official Raylib docs

However, here is a list of available functions:

## Functions API reference

`raylib.``AudioStream`

`raylib.``BLEND_ADDITIVE`

`raylib.``BLEND_ADD_COLORS`

`raylib.``BLEND_ALPHA`

`raylib.``BLEND_CUSTOM`

`raylib.``BLEND_MULTIPLIED`

`raylib.``BLEND_SUBTRACT_COLORS`

`raylib.``BeginBlendMode`(mode: int)

  Begin blending mode (alpha, additive, multiplied, subtract, custom)

`raylib.``BeginDrawing`()

  Setup canvas (framebuffer) to start drawing

`raylib.``BeginMode2D`(camera: Camera2D)

  Begin 2D mode with custom camera (2D)

`raylib.``BeginMode3D`(camera: Camera3D)

  Begin 3D mode with custom camera (3D)

`raylib.``BeginScissorMode`(x: int, y: int, width: int, height: int)

  Begin scissor mode (define screen area for following drawing)

`raylib.``BeginShaderMode`(shader: Shader)

  Begin custom shader drawing

`raylib.``BeginTextureMode`(target: RenderTexture)

  Begin drawing to render texture

`raylib.``BeginVrStereoMode`(config: VrStereoConfig)

  Begin stereo rendering (requires VR simulator)

`raylib.``BlendMode`

`raylib.``BoneInfo`

`raylib.``BoundingBox`

`raylib.``CAMERA_CUSTOM`

`raylib.``CAMERA_FIRST_PERSON`

`raylib.``CAMERA_FREE`

`raylib.``CAMERA_ORBITAL`

`raylib.``CAMERA_ORTHOGRAPHIC`

`raylib.``CAMERA_PERSPECTIVE`

`raylib.``CAMERA_THIRD_PERSON`

`raylib.``CUBEMAP_LAYOUT_AUTO_DETECT`

`raylib.``CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE`

`raylib.``CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR`

`raylib.``CUBEMAP_LAYOUT_LINE_HORIZONTAL`

`raylib.``CUBEMAP_LAYOUT_LINE_VERTICAL`

`raylib.``CUBEMAP_LAYOUT_PANORAMA`

`raylib.``Camera`

`raylib.``Camera2D`

`raylib.``Camera3D`

`raylib.``CameraMode`

`raylib.``CameraProjection`

`raylib.``ChangeDirectory`(dir: str)

  Change working directory, return true on success

`raylib.``CharInfo`

`raylib.``CheckCollisionBoxSphere`(box: BoundingBox, center: Vector3, radius: float)

  Check collision between box and sphere

`raylib.``CheckCollisionBoxes`(box1: BoundingBox, box2: BoundingBox)

  Check collision between two bounding boxes

`raylib.``CheckCollisionCircleRec`(center: Vector2, radius: float, rec: Rectangle)

  Check collision between circle and rectangle

`raylib.``CheckCollisionCircles`(center1: Vector2, radius1: float, center2: Vector2, radius2: float)

  Check collision between two circles

`raylib.``CheckCollisionLines`(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: Any)

  Check the collision between two lines defined by two points each, returns collision point by reference

`raylib.``CheckCollisionPointCircle`(point: Vector2, center: Vector2, radius: float)

  Check if point is inside circle

`raylib.``CheckCollisionPointRec`(point: Vector2, rec: Rectangle)

  Check if point is inside rectangle

`raylib.``CheckCollisionPointTriangle`(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2)

  Check if point is inside a triangle

`raylib.``CheckCollisionRayBox`(Ray_0: Ray, BoundingBox_1: BoundingBox)

  _Bool CheckCollisionRayBox(struct Ray, struct BoundingBox);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CheckCollisionRaySphere`(Ray_0: Ray, Vector3_1: Vector3, float_2: float)

  _Bool CheckCollisionRaySphere(struct Ray, struct Vector3, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CheckCollisionRaySphereEx`(Ray_0: Ray, Vector3_1: Vector3, float_2: float, Vector3_pointer_3: Any)

  _Bool CheckCollisionRaySphereEx(struct Ray, struct Vector3, float, struct Vector3 *);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CheckCollisionRecs`(rec1: Rectangle, rec2: Rectangle)

  Check collision between two rectangles

`raylib.``CheckCollisionSpheres`(center1: Vector3, radius1: float, center2: Vector3, radius2: float)

  Check collision between two spheres

`raylib.``ClearBackground`(color: Color)

  Set background color (framebuffer clear color)

`raylib.``ClearDirectoryFiles`()

  Clear directory files paths buffers (free memory)

`raylib.``ClearDroppedFiles`()

  Clear dropped files paths buffer (free memory)

`raylib.``ClearWindowState`(flags: int)

  Clear window configuration state flags

`raylib.``CloseAudioDevice`()

  Close the audio device and context

`raylib.``CloseAudioStream`(AudioStream_0: AudioStream)

  void CloseAudioStream(struct AudioStream);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``CloseWindow`()

  Close window and unload OpenGL context

`raylib.``CodepointToUtf8`(codepoint: int, byteLength: Any)

  Encode codepoint into utf8 text (char array length returned as parameter)

`raylib.``Color`

`raylib.``ColorAlpha`(color: Color, alpha: float)

  Get color with alpha applied, alpha goes from 0.0f to 1.0f

`raylib.``ColorAlphaBlend`(dst: Color, src: Color, tint: Color)

  Get src alpha-blended into dst color with tint

`raylib.``ColorFromHSV`(hue: float, saturation: float, value: float)

  Get a Color from HSV values, hue [0..360], saturation/value [0..1]

`raylib.``ColorFromNormalized`(normalized: Vector4)

  Get Color from normalized values [0..1]

`raylib.``ColorNormalize`(color: Color)

  Get Color normalized as float [0..1]

`raylib.``ColorToHSV`(color: Color)

  Get HSV values for a Color, hue [0..360], saturation/value [0..1]

`raylib.``ColorToInt`(color: Color)

  Get hexadecimal value for a Color

`raylib.``CompressData`(data: str, dataLength: int, compDataLength: Any)

  Compress data (DEFLATE algorithm)

`raylib.``ConfigFlags`

`raylib.``CubemapLayout`

`raylib.``DecompressData`(compData: str, compDataLength: int, dataLength: Any)

  Decompress data (DEFLATE algorithm)

`raylib.``DirectoryExists`(dirPath: str)

  Check if a directory path exists

`raylib.``DisableCursor`()

  Disables cursor (lock cursor)

`raylib.``DrawBillboard`(camera: Camera3D, texture: Texture, position: Vector3, size: float, tint: Color)

  Draw a billboard texture

`raylib.``DrawBillboardRec`(camera: Camera3D, texture: Texture, source: Rectangle, position: Vector3, size: float, tint: Color)

  Draw a billboard texture defined by source

`raylib.``DrawBoundingBox`(box: BoundingBox, color: Color)

  Draw bounding box (wires)

`raylib.``DrawCircle`(centerX: int, centerY: int, radius: float, color: Color)

  Draw a color-filled circle

`raylib.``DrawCircle3D`(center: Vector3, radius: float, rotationAxis: Vector3, rotationAngle: float, color: Color)

  Draw a circle in 3D world space

`raylib.``DrawCircleGradient`(centerX: int, centerY: int, radius: float, color1: Color, color2: Color)

  Draw a gradient-filled circle

`raylib.``DrawCircleLines`(centerX: int, centerY: int, radius: float, color: Color)

  Draw circle outline

`raylib.``DrawCircleSector`(center: Vector2, radius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw a piece of a circle

`raylib.``DrawCircleSectorLines`(center: Vector2, radius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw circle sector outline

`raylib.``DrawCircleV`(center: Vector2, radius: float, color: Color)

  Draw a color-filled circle (Vector version)

`raylib.``DrawCube`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube

`raylib.``DrawCubeTexture`(texture: Texture, position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube textured

`raylib.``DrawCubeV`(position: Vector3, size: Vector3, color: Color)

  Draw cube (Vector version)

`raylib.``DrawCubeWires`(position: Vector3, width: float, height: float, length: float, color: Color)

  Draw cube wires

`raylib.``DrawCubeWiresV`(position: Vector3, size: Vector3, color: Color)

  Draw cube wires (Vector version)

`raylib.``DrawCylinder`(position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: int, color: Color)

  Draw a cylinder/cone

`raylib.``DrawCylinderWires`(position: Vector3, radiusTop: float, radiusBottom: float, height: float, slices: int, color: Color)

  Draw a cylinder/cone wires

`raylib.``DrawEllipse`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse

`raylib.``DrawEllipseLines`(centerX: int, centerY: int, radiusH: float, radiusV: float, color: Color)

  Draw ellipse outline

`raylib.``DrawFPS`(posX: int, posY: int)

  Draw current FPS

`raylib.``DrawGrid`(slices: int, spacing: float)

  Draw a grid (centered at (0, 0, 0))

`raylib.``DrawLine`(startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw a line

`raylib.``DrawLine3D`(startPos: Vector3, endPos: Vector3, color: Color)

  Draw a line in 3D world space

`raylib.``DrawLineBezier`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line using cubic-bezier curves in-out

`raylib.``DrawLineBezierQuad`(startPos: Vector2, endPos: Vector2, controlPos: Vector2, thick: float, color: Color)

  raw line using quadratic bezier curves with a control point

`raylib.``DrawLineEx`(startPos: Vector2, endPos: Vector2, thick: float, color: Color)

  Draw a line defining thickness

`raylib.``DrawLineStrip`(points: Any, pointsCount: int, color: Color)

  Draw lines sequence

`raylib.``DrawLineV`(startPos: Vector2, endPos: Vector2, color: Color)

  Draw a line (Vector version)

`raylib.``DrawMesh`(mesh: Mesh, material: Material, transform: Matrix)

  Draw a 3d mesh with material and transform

`raylib.``DrawMeshInstanced`(mesh: Mesh, material: Material, transforms: Any, instances: int)

  Draw multiple mesh instances with material and different transforms

`raylib.``DrawModel`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model (with texture if set)

`raylib.``DrawModelEx`(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

  Draw a model with extended parameters

`raylib.``DrawModelWires`(model: Model, position: Vector3, scale: float, tint: Color)

  Draw a model wires (with texture if set)

`raylib.``DrawModelWiresEx`(model: Model, position: Vector3, rotationAxis: Vector3, rotationAngle: float, scale: Vector3, tint: Color)

  Draw a model wires (with texture if set) with extended parameters

`raylib.``DrawPixel`(posX: int, posY: int, color: Color)

  Draw a pixel

`raylib.``DrawPixelV`(position: Vector2, color: Color)

  Draw a pixel (Vector version)

`raylib.``DrawPlane`(centerPos: Vector3, size: Vector2, color: Color)

  Draw a plane XZ

`raylib.``DrawPoint3D`(position: Vector3, color: Color)

  Draw a point in 3D space, actually a small line

`raylib.``DrawPoly`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a regular polygon (Vector version)

`raylib.``DrawPolyLines`(center: Vector2, sides: int, radius: float, rotation: float, color: Color)

  Draw a polygon outline of n sides

`raylib.``DrawRay`(ray: Ray, color: Color)

  Draw a ray line

`raylib.``DrawRectangle`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw a color-filled rectangle

`raylib.``DrawRectangleGradientEx`(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color)

  Draw a gradient-filled rectangle with custom vertex colors

`raylib.``DrawRectangleGradientH`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a horizontal-gradient-filled rectangle

`raylib.``DrawRectangleGradientV`(posX: int, posY: int, width: int, height: int, color1: Color, color2: Color)

  Draw a vertical-gradient-filled rectangle

`raylib.``DrawRectangleLines`(posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle outline

`raylib.``DrawRectangleLinesEx`(rec: Rectangle, lineThick: int, color: Color)

  Draw rectangle outline with extended parameters

`raylib.``DrawRectanglePro`(rec: Rectangle, origin: Vector2, rotation: float, color: Color)

  Draw a color-filled rectangle with pro parameters

`raylib.``DrawRectangleRec`(rec: Rectangle, color: Color)

  Draw a color-filled rectangle

`raylib.``DrawRectangleRounded`(rec: Rectangle, roundness: float, segments: int, color: Color)

  Draw rectangle with rounded edges

`raylib.``DrawRectangleRoundedLines`(rec: Rectangle, roundness: float, segments: int, lineThick: int, color: Color)

  Draw rectangle with rounded edges outline

`raylib.``DrawRectangleV`(position: Vector2, size: Vector2, color: Color)

  Draw a color-filled rectangle (Vector version)

`raylib.``DrawRing`(center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw ring

`raylib.``DrawRingLines`(center: Vector2, innerRadius: float, outerRadius: float, startAngle: float, endAngle: float, segments: int, color: Color)

  Draw ring outline

`raylib.``DrawSphere`(centerPos: Vector3, radius: float, color: Color)

  Draw sphere

`raylib.``DrawSphereEx`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere with extended parameters

`raylib.``DrawSphereWires`(centerPos: Vector3, radius: float, rings: int, slices: int, color: Color)

  Draw sphere wires

`raylib.``DrawText`(text: str, posX: int, posY: int, fontSize: int, color: Color)

  Draw text (using default font)

`raylib.``DrawTextCodepoint`(font: Font, codepoint: int, position: Vector2, fontSize: float, tint: Color)

  Draw one character (codepoint)

`raylib.``DrawTextEx`(font: Font, text: str, position: Vector2, fontSize: float, spacing: float, tint: Color)

  Draw text using font and additional parameters

`raylib.``DrawTextRec`(font: Font, text: str, rec: Rectangle, fontSize: float, spacing: float, wordWrap: bool, tint: Color)

  Draw text using font inside rectangle limits

`raylib.``DrawTextRecEx`(font: Font, text: str, rec: Rectangle, fontSize: float, spacing: float, wordWrap: bool, tint: Color, selectStart: int, selectLength: int, selectTint: Color, selectBackTint: Color)

  Draw text using font inside rectangle limits with support for text selection

`raylib.``DrawTexture`(texture: Texture, posX: int, posY: int, tint: Color)

  Draw a Texture2D

`raylib.``DrawTextureEx`(texture: Texture, position: Vector2, rotation: float, scale: float, tint: Color)

  Draw a Texture2D with extended parameters

`raylib.``DrawTextureNPatch`(texture: Texture, nPatchInfo: NPatchInfo, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

  Draws a texture (or part of it) that stretches or shrinks nicely

`raylib.``DrawTexturePoly`(texture: Texture, center: Vector2, points: Any, texcoords: Any, pointsCount: int, tint: Color)

  Draw a textured polygon

`raylib.``DrawTexturePro`(texture: Texture, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, tint: Color)

  Draw a part of a texture defined by a rectangle with ‘pro’ parameters

`raylib.``DrawTextureQuad`(texture: Texture, tiling: Vector2, offset: Vector2, quad: Rectangle, tint: Color)

  Draw texture quad with tiling and offset parameters

`raylib.``DrawTextureRec`(texture: Texture, source: Rectangle, position: Vector2, tint: Color)

  Draw a part of a texture defined by a rectangle

`raylib.``DrawTextureTiled`(texture: Texture, source: Rectangle, dest: Rectangle, origin: Vector2, rotation: float, scale: float, tint: Color)

  Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.

`raylib.``DrawTextureV`(texture: Texture, position: Vector2, tint: Color)

  Draw a Texture2D with position defined as Vector2

`raylib.``DrawTriangle`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

  Draw a color-filled triangle (vertex in counter-clockwise order!)

`raylib.``DrawTriangle3D`(v1: Vector3, v2: Vector3, v3: Vector3, color: Color)

  Draw a color-filled triangle (vertex in counter-clockwise order!)

`raylib.``DrawTriangleFan`(points: Any, pointsCount: int, color: Color)

  Draw a triangle fan defined by points (first vertex is the center)

`raylib.``DrawTriangleLines`(v1: Vector2, v2: Vector2, v3: Vector2, color: Color)

  Draw triangle outline (vertex in counter-clockwise order!)

`raylib.``DrawTriangleStrip`(points: Any, pointsCount: int, color: Color)

  Draw a triangle strip defined by points

`raylib.``DrawTriangleStrip3D`(points: Any, pointsCount: int, color: Color)

  Draw a triangle strip defined by points

`raylib.``EnableCursor`()

  Enables cursor (unlock cursor)

`raylib.``EndBlendMode`()

  End blending mode (reset to default: alpha blending)

`raylib.``EndDrawing`()

  End canvas drawing and swap buffers (double buffering)

`raylib.``EndMode2D`()

  Ends 2D mode with custom camera

`raylib.``EndMode3D`()

  Ends 3D mode and returns to default 2D orthographic mode

`raylib.``EndScissorMode`()

  End scissor mode

`raylib.``EndShaderMode`()

  End custom shader drawing (use default shader)

`raylib.``EndTextureMode`()

  Ends drawing to render texture

`raylib.``EndVrStereoMode`()

  End stereo rendering (requires VR simulator)

`raylib.``ExportImage`(image: Image, fileName: str)

  Export image data to file, returns true on success

`raylib.``ExportImageAsCode`(image: Image, fileName: str)

  Export image as code file defining an array of bytes, returns true on success

`raylib.``ExportMesh`(mesh: Mesh, fileName: str)

  Export mesh data to file, returns true on success

`raylib.``ExportWave`(wave: Wave, fileName: str)

  Export wave data to file, returns true on success

`raylib.``ExportWaveAsCode`(wave: Wave, fileName: str)

  Export wave sample data to code (.h), returns true on success

`raylib.``FLAG_FULLSCREEN_MODE`

`raylib.``FLAG_INTERLACED_HINT`

`raylib.``FLAG_MSAA_4X_HINT`

`raylib.``FLAG_VSYNC_HINT`

`raylib.``FLAG_WINDOW_ALWAYS_RUN`

`raylib.``FLAG_WINDOW_HIDDEN`

`raylib.``FLAG_WINDOW_HIGHDPI`

`raylib.``FLAG_WINDOW_MAXIMIZED`

`raylib.``FLAG_WINDOW_MINIMIZED`

`raylib.``FLAG_WINDOW_RESIZABLE`

`raylib.``FLAG_WINDOW_TOPMOST`

`raylib.``FLAG_WINDOW_TRANSPARENT`

`raylib.``FLAG_WINDOW_UNDECORATED`

`raylib.``FLAG_WINDOW_UNFOCUSED`

`raylib.``FONT_BITMAP`

`raylib.``FONT_DEFAULT`

`raylib.``FONT_SDF`

`raylib.``Fade`(color: Color, alpha: float)

  Get color with alpha applied, alpha goes from 0.0f to 1.0f

`raylib.``FileExists`(fileName: str)

  Check if file exists

`raylib.``Font`

`raylib.``FontType`

`raylib.``GAMEPAD_AXIS_LEFT_TRIGGER`

`raylib.``GAMEPAD_AXIS_LEFT_X`

`raylib.``GAMEPAD_AXIS_LEFT_Y`

`raylib.``GAMEPAD_AXIS_RIGHT_TRIGGER`

`raylib.``GAMEPAD_AXIS_RIGHT_X`

`raylib.``GAMEPAD_AXIS_RIGHT_Y`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_DOWN`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_LEFT`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_RIGHT`

`raylib.``GAMEPAD_BUTTON_LEFT_FACE_UP`

`raylib.``GAMEPAD_BUTTON_LEFT_THUMB`

`raylib.``GAMEPAD_BUTTON_LEFT_TRIGGER_1`

`raylib.``GAMEPAD_BUTTON_LEFT_TRIGGER_2`

`raylib.``GAMEPAD_BUTTON_MIDDLE`

`raylib.``GAMEPAD_BUTTON_MIDDLE_LEFT`

`raylib.``GAMEPAD_BUTTON_MIDDLE_RIGHT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_DOWN`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_LEFT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_RIGHT`

`raylib.``GAMEPAD_BUTTON_RIGHT_FACE_UP`

`raylib.``GAMEPAD_BUTTON_RIGHT_THUMB`

`raylib.``GAMEPAD_BUTTON_RIGHT_TRIGGER_1`

`raylib.``GAMEPAD_BUTTON_RIGHT_TRIGGER_2`

`raylib.``GAMEPAD_BUTTON_UNKNOWN`

`raylib.``GESTURE_DOUBLETAP`

`raylib.``GESTURE_DRAG`

`raylib.``GESTURE_HOLD`

`raylib.``GESTURE_NONE`

`raylib.``GESTURE_PINCH_IN`

`raylib.``GESTURE_PINCH_OUT`

`raylib.``GESTURE_SWIPE_DOWN`

`raylib.``GESTURE_SWIPE_LEFT`

`raylib.``GESTURE_SWIPE_RIGHT`

`raylib.``GESTURE_SWIPE_UP`

`raylib.``GESTURE_TAP`

`raylib.``GamepadAxis`

`raylib.``GamepadButton`

`raylib.``GenImageCellular`(width: int, height: int, tileSize: int)

  Generate image: cellular algorithm. Bigger tileSize means bigger cells

`raylib.``GenImageChecked`(width: int, height: int, checksX: int, checksY: int, col1: Color, col2: Color)

  Generate image: checked

`raylib.``GenImageColor`(width: int, height: int, color: Color)

  Generate image: plain color

`raylib.``GenImageFontAtlas`(chars: Any, recs: Any, charsCount: int, fontSize: int, padding: int, packMethod: int)

  Generate image font atlas using chars info

`raylib.``GenImageGradientH`(width: int, height: int, left: Color, right: Color)

  Generate image: horizontal gradient

`raylib.``GenImageGradientRadial`(width: int, height: int, density: float, inner: Color, outer: Color)

  Generate image: radial gradient

`raylib.``GenImageGradientV`(width: int, height: int, top: Color, bottom: Color)

  Generate image: vertical gradient

`raylib.``GenImagePerlinNoise`(width: int, height: int, offsetX: int, offsetY: int, scale: float)

  Generate image: perlin noise

`raylib.``GenImageWhiteNoise`(width: int, height: int, factor: float)

  Generate image: white noise

`raylib.``GenMeshCube`(width: float, height: float, length: float)

  Generate cuboid mesh

`raylib.``GenMeshCubicmap`(cubicmap: Image, cubeSize: Vector3)

  Generate cubes-based map mesh from image data

`raylib.``GenMeshCylinder`(radius: float, height: float, slices: int)

  Generate cylinder mesh

`raylib.``GenMeshHeightmap`(heightmap: Image, size: Vector3)

  Generate heightmap mesh from image data

`raylib.``GenMeshHemiSphere`(radius: float, rings: int, slices: int)

  Generate half-sphere mesh (no bottom cap)

`raylib.``GenMeshKnot`(radius: float, size: float, radSeg: int, sides: int)

  Generate trefoil knot mesh

`raylib.``GenMeshPlane`(width: float, length: float, resX: int, resZ: int)

  Generate plane mesh (with subdivisions)

`raylib.``GenMeshPoly`(sides: int, radius: float)

  Generate polygonal mesh

`raylib.``GenMeshSphere`(radius: float, rings: int, slices: int)

  Generate sphere mesh (standard sphere)

`raylib.``GenMeshTorus`(radius: float, size: float, radSeg: int, sides: int)

  Generate torus mesh

`raylib.``GenTextureMipmaps`(texture: Any)

  Generate GPU mipmaps for a texture

`raylib.``Gestures`

`raylib.``GetCameraMatrix`(camera: Camera3D)

  Get camera transform matrix (view matrix)

`raylib.``GetCameraMatrix2D`(camera: Camera2D)

  Get camera 2d transform matrix

`raylib.``GetCharPressed`()

  Get char pressed (unicode), call it multiple times for chars queued

`raylib.``GetClipboardText`()

  Get clipboard text content

`raylib.``GetCodepoints`(text: str, count: Any)

  Get all codepoints in a string, codepoints count returned by parameters

`raylib.``GetCodepointsCount`(text: str)

  Get total number of characters (codepoints) in a UTF8 encoded string

`raylib.``GetCollisionRayGround`(Ray_0: Ray, float_1: float)

  struct RayHitInfo GetCollisionRayGround(struct Ray, float);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetCollisionRayMesh`(Ray_0: Ray, Mesh_1: Mesh, Matrix_2: Matrix)

  struct RayHitInfo GetCollisionRayMesh(struct Ray, struct Mesh, struct Matrix);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetCollisionRayModel`(Ray_0: Ray, Model_1: Model)

  struct RayHitInfo GetCollisionRayModel(struct Ray, struct Model);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetCollisionRayTriangle`(Ray_0: Ray, Vector3_1: Vector3, Vector3_2: Vector3, Vector3_3: Vector3)

  struct RayHitInfo GetCollisionRayTriangle(struct Ray, struct Vector3, struct Vector3, struct Vector3);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``GetCollisionRec`(rec1: Rectangle, rec2: Rectangle)

  Get collision rectangle for two rectangles collision

`raylib.``GetColor`(hexValue: int)

  Get Color structure from hexadecimal value

`raylib.``GetCurrentMonitor`()

  Get current connected monitor

`raylib.``GetDirectoryFiles`(dirPath: str, count: Any)

  Get filenames in a directory path (memory should be freed)

`raylib.``GetDirectoryPath`(filePath: str)

  Get full path for a given fileName with path (uses static string)

`raylib.``GetDroppedFiles`(count: Any)

  Get dropped files names (memory should be freed)

`raylib.``GetFPS`()

  Get current FPS

`raylib.``GetFileExtension`(fileName: str)

  Get pointer to extension for a filename string (includes dot: ‘.png’)

`raylib.``GetFileModTime`(fileName: str)

  Get file modification time (last write time)

`raylib.``GetFileName`(filePath: str)

  Get pointer to filename for a path string

`raylib.``GetFileNameWithoutExt`(filePath: str)

  Get filename string without extension (uses static string)

`raylib.``GetFontDefault`()

  Get the default Font

`raylib.``GetFrameTime`()

  Get time in seconds for last frame drawn (delta time)

`raylib.``GetGamepadAxisCount`(gamepad: int)

  Get gamepad axis count for a gamepad

`raylib.``GetGamepadAxisMovement`(gamepad: int, axis: int)

  Get axis movement value for a gamepad axis

`raylib.``GetGamepadButtonPressed`()

  Get the last gamepad button pressed

`raylib.``GetGamepadName`(gamepad: int)

  Get gamepad internal name id

`raylib.``GetGestureDetected`()

  Get latest detected gesture

`raylib.``GetGestureDragAngle`()

  Get gesture drag angle

`raylib.``GetGestureDragVector`()

  Get gesture drag vector

`raylib.``GetGestureHoldDuration`()

  Get gesture hold time in milliseconds

`raylib.``GetGesturePinchAngle`()

  Get gesture pinch angle

`raylib.``GetGesturePinchVector`()

  Get gesture pinch delta

`raylib.``GetGlyphIndex`(font: Font, codepoint: int)

  Get index position for a unicode character on font

`raylib.``GetImageAlphaBorder`(image: Image, threshold: float)

  Get image alpha border rectangle

`raylib.``GetKeyPressed`()

  Get key pressed (keycode), call it multiple times for keys queued

`raylib.``GetMonitorCount`()

  Get number of connected monitors

`raylib.``GetMonitorHeight`(monitor: int)

  Get specified monitor height (max available by monitor)

`raylib.``GetMonitorName`(monitor: int)

  Get the human-readable, UTF-8 encoded name of the primary monitor

`raylib.``GetMonitorPhysicalHeight`(monitor: int)

  Get specified monitor physical height in millimetres

`raylib.``GetMonitorPhysicalWidth`(monitor: int)

  Get specified monitor physical width in millimetres

`raylib.``GetMonitorPosition`(monitor: int)

  Get specified monitor position

`raylib.``GetMonitorRefreshRate`(monitor: int)

  Get specified monitor refresh rate

`raylib.``GetMonitorWidth`(monitor: int)

  Get specified monitor width (max available by monitor)

`raylib.``GetMousePosition`()

  Get mouse position XY

`raylib.``GetMouseRay`(mousePosition: Vector2, camera: Camera3D)

  Get a ray trace from mouse position

`raylib.``GetMouseWheelMove`()

  Get mouse wheel movement Y

`raylib.``GetMouseX`()

  Get mouse position X

`raylib.``GetMouseY`()

  Get mouse position Y

`raylib.``GetMusicTimeLength`(music: Music)

  Get music time length (in seconds)

`raylib.``GetMusicTimePlayed`(music: Music)

  Get current music time played (in seconds)

`raylib.``GetNextCodepoint`(text: str, bytesProcessed: Any)

  Get next codepoint in a UTF8 encoded string; 0x3f(‘?’) is returned on failure

`raylib.``GetPixelColor`(srcPtr: Any, format: int)

  Get Color from a source pixel pointer of certain format

`raylib.``GetPixelDataSize`(width: int, height: int, format: int)

  Get pixel data size in bytes for certain format

`raylib.``GetPrevDirectoryPath`(dirPath: str)

  Get previous directory path for a given path (uses static string)

`raylib.``GetRandomValue`(min: int, max: int)

  Get a random value between min and max (both included)

`raylib.``GetScreenData`()

  Get pixel data from screen buffer and return an Image (screenshot)

`raylib.``GetScreenHeight`()

  Get current screen height

`raylib.``GetScreenToWorld2D`(position: Vector2, camera: Camera2D)

  Get the world space position for a 2d camera screen space position

`raylib.``GetScreenWidth`()

  Get current screen width

`raylib.``GetShaderLocation`(shader: Shader, uniformName: str)

  Get shader uniform location

`raylib.``GetShaderLocationAttrib`(shader: Shader, attribName: str)

  Get shader attribute location

`raylib.``GetSoundsPlaying`()

  Get number of sounds playing in the multichannel

`raylib.``GetTextureData`(texture: Texture)

  Get pixel data from GPU texture and return an Image

`raylib.``GetTime`()

  Get elapsed time in seconds since InitWindow()

`raylib.``GetTouchPointsCount`()

  Get touch points count

`raylib.``GetTouchPosition`(index: int)

  Get touch position XY for a touch point index (relative to screen size)

`raylib.``GetTouchX`()

  Get touch position X for touch point 0 (relative to screen size)

`raylib.``GetTouchY`()

  Get touch position Y for touch point 0 (relative to screen size)

`raylib.``GetWindowHandle`()

  Get native window handle

`raylib.``GetWindowPosition`()

  Get window position XY on monitor

`raylib.``GetWindowScaleDPI`()

  Get window scale DPI factor

`raylib.``GetWorkingDirectory`()

  Get current working directory (uses static string)

`raylib.``GetWorldToScreen`(position: Vector3, camera: Camera3D)

  Get the screen space position for a 3d world space position

`raylib.``GetWorldToScreen2D`(position: Vector2, camera: Camera2D)

  Get the screen space position for a 2d camera world space position

`raylib.``GetWorldToScreenEx`(position: Vector3, camera: Camera3D, width: int, height: int)

  Get size position for a 3d world space position

`raylib.``HideCursor`()

  Hides cursor

`raylib.``Image`

`raylib.``ImageAlphaClear`(image: Any, color: Color, threshold: float)

  Clear alpha channel to desired color

`raylib.``ImageAlphaCrop`(image: Any, threshold: float)

  Crop image depending on alpha value

`raylib.``ImageAlphaMask`(image: Any, alphaMask: Image)

  Apply alpha mask to image

`raylib.``ImageAlphaPremultiply`(image: Any)

  Premultiply alpha channel

`raylib.``ImageClearBackground`(dst: Any, color: Color)

  Clear image background with given color

`raylib.``ImageColorBrightness`(image: Any, brightness: int)

  Modify image color: brightness (-255 to 255)

`raylib.``ImageColorContrast`(image: Any, contrast: float)

  Modify image color: contrast (-100 to 100)

`raylib.``ImageColorGrayscale`(image: Any)

  Modify image color: grayscale

`raylib.``ImageColorInvert`(image: Any)

  Modify image color: invert

`raylib.``ImageColorReplace`(image: Any, color: Color, replace: Color)

  Modify image color: replace color

`raylib.``ImageColorTint`(image: Any, color: Color)

  Modify image color: tint

`raylib.``ImageCopy`(image: Image)

  Create an image duplicate (useful for transformations)

`raylib.``ImageCrop`(image: Any, crop: Rectangle)

  Crop an image to a defined rectangle

`raylib.``ImageDither`(image: Any, rBpp: int, gBpp: int, bBpp: int, aBpp: int)

  Dither image data to 16bpp or lower (Floyd-Steinberg dithering)

`raylib.``ImageDraw`(dst: Any, src: Image, srcRec: Rectangle, dstRec: Rectangle, tint: Color)

  Draw a source image within a destination image (tint applied to source)

`raylib.``ImageDrawCircle`(dst: Any, centerX: int, centerY: int, radius: int, color: Color)

  Draw circle within an image

`raylib.``ImageDrawCircleV`(dst: Any, center: Vector2, radius: int, color: Color)

  Draw circle within an image (Vector version)

`raylib.``ImageDrawLine`(dst: Any, startPosX: int, startPosY: int, endPosX: int, endPosY: int, color: Color)

  Draw line within an image

`raylib.``ImageDrawLineV`(dst: Any, start: Vector2, end: Vector2, color: Color)

  Draw line within an image (Vector version)

`raylib.``ImageDrawPixel`(dst: Any, posX: int, posY: int, color: Color)

  Draw pixel within an image

`raylib.``ImageDrawPixelV`(dst: Any, position: Vector2, color: Color)

  Draw pixel within an image (Vector version)

`raylib.``ImageDrawRectangle`(dst: Any, posX: int, posY: int, width: int, height: int, color: Color)

  Draw rectangle within an image

`raylib.``ImageDrawRectangleLines`(dst: Any, rec: Rectangle, thick: int, color: Color)

  Draw rectangle lines within an image

`raylib.``ImageDrawRectangleRec`(dst: Any, rec: Rectangle, color: Color)

  Draw rectangle within an image

`raylib.``ImageDrawRectangleV`(dst: Any, position: Vector2, size: Vector2, color: Color)

  Draw rectangle within an image (Vector version)

`raylib.``ImageDrawText`(dst: Any, text: str, posX: int, posY: int, fontSize: int, color: Color)

  Draw text (using default font) within an image (destination)

`raylib.``ImageDrawTextEx`(dst: Any, font: Font, text: str, position: Vector2, fontSize: float, spacing: float, tint: Color)

  Draw text (custom sprite font) within an image (destination)

`raylib.``ImageFlipHorizontal`(image: Any)

  Flip image horizontally

`raylib.``ImageFlipVertical`(image: Any)

  Flip image vertically

`raylib.``ImageFormat`(image: Any, newFormat: int)

  Convert image data to desired format

`raylib.``ImageFromImage`(image: Image, rec: Rectangle)

  Create an image from another image piece

`raylib.``ImageMipmaps`(image: Any)

  Compute all mipmap levels for a provided image

`raylib.``ImageResize`(image: Any, newWidth: int, newHeight: int)

  Resize image (Bicubic scaling algorithm)

`raylib.``ImageResizeCanvas`(image: Any, newWidth: int, newHeight: int, offsetX: int, offsetY: int, fill: Color)

  Resize canvas and fill with color

`raylib.``ImageResizeNN`(image: Any, newWidth: int, newHeight: int)

  Resize image (Nearest-Neighbor scaling algorithm)

`raylib.``ImageRotateCCW`(image: Any)

  Rotate image counter-clockwise 90deg

`raylib.``ImageRotateCW`(image: Any)

  Rotate image clockwise 90deg

`raylib.``ImageText`(text: str, fontSize: int, color: Color)

  Create an image from text (default font)

`raylib.``ImageTextEx`(font: Font, text: str, fontSize: float, spacing: float, tint: Color)

  Create an image from text (custom sprite font)

`raylib.``ImageToPOT`(image: Any, fill: Color)

  Convert image to POT (power-of-two)

`raylib.``InitAudioDevice`()

  Initialize audio device and context

`raylib.``InitAudioStream`(unsignedint_0: int, unsignedint_1: int, unsignedint_2: int)

  struct AudioStream InitAudioStream(unsigned int, unsigned int, unsigned int);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``InitWindow`(width: int, height: int, title: str)

  Initialize window and OpenGL context

`raylib.``IsAudioDeviceReady`()

  Check if audio device has been initialized successfully

`raylib.``IsAudioStreamPlaying`(stream: AudioStream)

  Check if audio stream is playing

`raylib.``IsAudioStreamProcessed`(stream: AudioStream)

  Check if any audio stream buffers requires refill

`raylib.``IsCursorHidden`()

  Check if cursor is not visible

`raylib.``IsCursorOnScreen`()

  Check if cursor is on the screen

`raylib.``IsFileDropped`()

  Check if a file has been dropped into window

`raylib.``IsFileExtension`(fileName: str, ext: str)

  Check file extension (including point: .png, .wav)

`raylib.``IsGamepadAvailable`(gamepad: int)

  Check if a gamepad is available

`raylib.``IsGamepadButtonDown`(gamepad: int, button: int)

  Check if a gamepad button is being pressed

`raylib.``IsGamepadButtonPressed`(gamepad: int, button: int)

  Check if a gamepad button has been pressed once

`raylib.``IsGamepadButtonReleased`(gamepad: int, button: int)

  Check if a gamepad button has been released once

`raylib.``IsGamepadButtonUp`(gamepad: int, button: int)

  Check if a gamepad button is NOT being pressed

`raylib.``IsGamepadName`(gamepad: int, name: str)

  Check gamepad name (if available)

`raylib.``IsGestureDetected`(gesture: int)

  Check if a gesture have been detected

`raylib.``IsKeyDown`(key: int)

  Check if a key is being pressed

`raylib.``IsKeyPressed`(key: int)

  Check if a key has been pressed once

`raylib.``IsKeyReleased`(key: int)

  Check if a key has been released once

`raylib.``IsKeyUp`(key: int)

  Check if a key is NOT being pressed

`raylib.``IsModelAnimationValid`(model: Model, anim: ModelAnimation)

  Check model animation skeleton match

`raylib.``IsMouseButtonDown`(button: int)

  Check if a mouse button is being pressed

`raylib.``IsMouseButtonPressed`(button: int)

  Check if a mouse button has been pressed once

`raylib.``IsMouseButtonReleased`(button: int)

  Check if a mouse button has been released once

`raylib.``IsMouseButtonUp`(button: int)

  Check if a mouse button is NOT being pressed

`raylib.``IsMusicPlaying`(Music_0: Music)

  _Bool IsMusicPlaying(struct Music);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``IsSoundPlaying`(sound: Sound)

  Check if a sound is currently playing

`raylib.``IsWindowFocused`()

  Check if window is currently focused (only PLATFORM_DESKTOP)

`raylib.``IsWindowFullscreen`()

  Check if window is currently fullscreen

`raylib.``IsWindowHidden`()

  Check if window is currently hidden (only PLATFORM_DESKTOP)

`raylib.``IsWindowMaximized`()

  Check if window is currently maximized (only PLATFORM_DESKTOP)

`raylib.``IsWindowMinimized`()

  Check if window is currently minimized (only PLATFORM_DESKTOP)

`raylib.``IsWindowReady`()

  Check if window has been initialized successfully

`raylib.``IsWindowResized`()

  Check if window has been resized last frame

`raylib.``IsWindowState`(flag: int)

  Check if one specific window flag is enabled

`raylib.``KEY_A`

`raylib.``KEY_APOSTROPHE`

`raylib.``KEY_B`

`raylib.``KEY_BACK`

`raylib.``KEY_BACKSLASH`

`raylib.``KEY_BACKSPACE`

`raylib.``KEY_C`

`raylib.``KEY_CAPS_LOCK`

`raylib.``KEY_COMMA`

`raylib.``KEY_D`

`raylib.``KEY_DELETE`

`raylib.``KEY_DOWN`

`raylib.``KEY_E`

`raylib.``KEY_EIGHT`

`raylib.``KEY_END`

`raylib.``KEY_ENTER`

`raylib.``KEY_EQUAL`

`raylib.``KEY_ESCAPE`

`raylib.``KEY_F`

`raylib.``KEY_F1`

`raylib.``KEY_F10`

`raylib.``KEY_F11`

`raylib.``KEY_F12`

`raylib.``KEY_F2`

`raylib.``KEY_F3`

`raylib.``KEY_F4`

`raylib.``KEY_F5`

`raylib.``KEY_F6`

`raylib.``KEY_F7`

`raylib.``KEY_F8`

`raylib.``KEY_F9`

`raylib.``KEY_FIVE`

`raylib.``KEY_FOUR`

`raylib.``KEY_G`

`raylib.``KEY_GRAVE`

`raylib.``KEY_H`

`raylib.``KEY_HOME`

`raylib.``KEY_I`

`raylib.``KEY_INSERT`

`raylib.``KEY_J`

`raylib.``KEY_K`

`raylib.``KEY_KB_MENU`

`raylib.``KEY_KP_0`

`raylib.``KEY_KP_1`

`raylib.``KEY_KP_2`

`raylib.``KEY_KP_3`

`raylib.``KEY_KP_4`

`raylib.``KEY_KP_5`

`raylib.``KEY_KP_6`

`raylib.``KEY_KP_7`

`raylib.``KEY_KP_8`

`raylib.``KEY_KP_9`

`raylib.``KEY_KP_ADD`

`raylib.``KEY_KP_DECIMAL`

`raylib.``KEY_KP_DIVIDE`

`raylib.``KEY_KP_ENTER`

`raylib.``KEY_KP_EQUAL`

`raylib.``KEY_KP_MULTIPLY`

`raylib.``KEY_KP_SUBTRACT`

`raylib.``KEY_L`

`raylib.``KEY_LEFT`

`raylib.``KEY_LEFT_ALT`

`raylib.``KEY_LEFT_BRACKET`

`raylib.``KEY_LEFT_CONTROL`

`raylib.``KEY_LEFT_SHIFT`

`raylib.``KEY_LEFT_SUPER`

`raylib.``KEY_M`

`raylib.``KEY_MENU`

`raylib.``KEY_MINUS`

`raylib.``KEY_N`

`raylib.``KEY_NINE`

`raylib.``KEY_NULL`

`raylib.``KEY_NUM_LOCK`

`raylib.``KEY_O`

`raylib.``KEY_ONE`

`raylib.``KEY_P`

`raylib.``KEY_PAGE_DOWN`

`raylib.``KEY_PAGE_UP`

`raylib.``KEY_PAUSE`

`raylib.``KEY_PERIOD`

`raylib.``KEY_PRINT_SCREEN`

`raylib.``KEY_Q`

`raylib.``KEY_R`

`raylib.``KEY_RIGHT`

`raylib.``KEY_RIGHT_ALT`

`raylib.``KEY_RIGHT_BRACKET`

`raylib.``KEY_RIGHT_CONTROL`

`raylib.``KEY_RIGHT_SHIFT`

`raylib.``KEY_RIGHT_SUPER`

`raylib.``KEY_S`

`raylib.``KEY_SCROLL_LOCK`

`raylib.``KEY_SEMICOLON`

`raylib.``KEY_SEVEN`

`raylib.``KEY_SIX`

`raylib.``KEY_SLASH`

`raylib.``KEY_SPACE`

`raylib.``KEY_T`

`raylib.``KEY_TAB`

`raylib.``KEY_THREE`

`raylib.``KEY_TWO`

`raylib.``KEY_U`

`raylib.``KEY_UP`

`raylib.``KEY_V`

`raylib.``KEY_VOLUME_DOWN`

`raylib.``KEY_VOLUME_UP`

`raylib.``KEY_W`

`raylib.``KEY_X`

`raylib.``KEY_Y`

`raylib.``KEY_Z`

`raylib.``KEY_ZERO`

`raylib.``KeyboardKey`

`raylib.``LOG_ALL`

`raylib.``LOG_DEBUG`

`raylib.``LOG_ERROR`

`raylib.``LOG_FATAL`

`raylib.``LOG_INFO`

`raylib.``LOG_NONE`

`raylib.``LOG_TRACE`

`raylib.``LOG_WARNING`

`raylib.``LoadFileData`(fileName: str, bytesRead: Any)

  Load file data as byte array (read)

`raylib.``LoadFileText`(fileName: str)

  Load text data from file (read), returns a ‘ 0’ terminated string

`raylib.``LoadFont`(fileName: str)

  Load font from file into GPU memory (VRAM)

`raylib.``LoadFontData`(fileData: str, dataSize: int, fontSize: int, fontChars: Any, charsCount: int, type: int)

  Load font data for further use

`raylib.``LoadFontEx`(fileName: str, fontSize: int, fontChars: Any, charsCount: int)

  Load font from file with extended parameters

`raylib.``LoadFontFromImage`(image: Image, key: Color, firstChar: int)

  Load font from Image (XNA style)

`raylib.``LoadFontFromMemory`(fileType: str, fileData: str, dataSize: int, fontSize: int, fontChars: Any, charsCount: int)

  Load font from memory buffer, fileType refers to extension: i.e. ‘.ttf’

`raylib.``LoadImage`(fileName: str)

  Load image from file into CPU memory (RAM)

`raylib.``LoadImageAnim`(fileName: str, frames: Any)

  Load image sequence from file (frames appended to image.data)

`raylib.``LoadImageColors`(image: Image)

  Load color data from image as a Color array (RGBA - 32bit)

`raylib.``LoadImageFromMemory`(fileType: str, fileData: str, dataSize: int)

  Load image from memory buffer, fileType refers to extension: i.e. ‘.png’

`raylib.``LoadImagePalette`(image: Image, maxPaletteSize: int, colorsCount: Any)

  Load colors palette from image as a Color array (RGBA - 32bit)

`raylib.``LoadImageRaw`(fileName: str, width: int, height: int, format: int, headerSize: int)

  Load image from RAW file data

`raylib.``LoadMaterialDefault`()

  Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)

`raylib.``LoadMaterials`(fileName: str, materialCount: Any)

  Load materials from model file

`raylib.``LoadModel`(fileName: str)

  Load model from files (meshes and materials)

`raylib.``LoadModelAnimations`(fileName: str, animsCount: Any)

  Load model animations from file

`raylib.``LoadModelFromMesh`(mesh: Mesh)

  Load model from generated mesh (default material)

`raylib.``LoadMusicStream`(fileName: str)

  Load music stream from file

`raylib.``LoadMusicStreamFromMemory`(fileType: str, data: str, dataSize: int)

  Load music stream from data

`raylib.``LoadRenderTexture`(width: int, height: int)

  Load texture for rendering (framebuffer)

`raylib.``LoadShader`(vsFileName: str, fsFileName: str)

  Load shader from files and bind default locations

`raylib.``LoadShaderFromMemory`(vsCode: str, fsCode: str)

  Load shader from code strings and bind default locations

`raylib.``LoadSound`(fileName: str)

  Load sound from file

`raylib.``LoadSoundFromWave`(wave: Wave)

  Load sound from wave data

`raylib.``LoadStorageValue`(position: int)

  Load integer value from storage file (from defined position)

`raylib.``LoadTexture`(fileName: str)

  Load texture from file into GPU memory (VRAM)

`raylib.``LoadTextureCubemap`(image: Image, layout: int)

  Load cubemap from image, multiple image cubemap layouts supported

`raylib.``LoadTextureFromImage`(image: Image)

  Load texture from image data

`raylib.``LoadVrStereoConfig`(device: VrDeviceInfo)

  Load VR stereo config for VR simulator device parameters

`raylib.``LoadWave`(fileName: str)

  Load wave data from file

`raylib.``LoadWaveFromMemory`(fileType: str, fileData: str, dataSize: int)

  Load wave from memory buffer, fileType refers to extension: i.e. ‘.wav’

`raylib.``LoadWaveSamples`(wave: Wave)

  Load samples data from wave as a floats array

`raylib.``MATERIAL_MAP_ALBEDO`

`raylib.``MATERIAL_MAP_BRDG`

`raylib.``MATERIAL_MAP_CUBEMAP`

`raylib.``MATERIAL_MAP_DIFFUSE`

`raylib.``MATERIAL_MAP_EMISSION`

`raylib.``MATERIAL_MAP_HEIGHT`

`raylib.``MATERIAL_MAP_IRRADIANCE`

`raylib.``MATERIAL_MAP_METALNESS`

`raylib.``MATERIAL_MAP_NORMAL`

`raylib.``MATERIAL_MAP_OCCLUSION`

`raylib.``MATERIAL_MAP_PREFILTER`

`raylib.``MATERIAL_MAP_ROUGHNESS`

`raylib.``MATERIAL_MAP_SPECULAR`

`raylib.``MOUSE_CURSOR_ARROW`

`raylib.``MOUSE_CURSOR_CROSSHAIR`

`raylib.``MOUSE_CURSOR_DEFAULT`

`raylib.``MOUSE_CURSOR_IBEAM`

`raylib.``MOUSE_CURSOR_NOT_ALLOWED`

`raylib.``MOUSE_CURSOR_POINTING_HAND`

`raylib.``MOUSE_CURSOR_RESIZE_ALL`

`raylib.``MOUSE_CURSOR_RESIZE_EW`

`raylib.``MOUSE_CURSOR_RESIZE_NESW`

`raylib.``MOUSE_CURSOR_RESIZE_NS`

`raylib.``MOUSE_CURSOR_RESIZE_NWSE`

`raylib.``MOUSE_LEFT_BUTTON`

`raylib.``MOUSE_MIDDLE_BUTTON`

`raylib.``MOUSE_RIGHT_BUTTON`

`raylib.``Material`

`raylib.``MaterialMap`

`raylib.``MaterialMapIndex`

`raylib.``Matrix`

`raylib.``MaximizeWindow`()

  Set window state: maximized, if resizable (only PLATFORM_DESKTOP)

`raylib.``MeasureText`(text: str, fontSize: int)

  Measure string width for default font

`raylib.``MeasureTextEx`(font: Font, text: str, fontSize: float, spacing: float)

  Measure string size for Font

`raylib.``MemAlloc`(size: int)

  Internal memory allocator

`raylib.``MemFree`(ptr: Any)

  Internal memory free

`raylib.``MemRealloc`(ptr: Any, size: int)

  Internal memory reallocator

`raylib.``Mesh`

`raylib.``MeshBinormals`(mesh: Any)

  Compute mesh binormals

`raylib.``MeshBoundingBox`(Mesh_0: Mesh)

  struct BoundingBox MeshBoundingBox(struct Mesh);

  CFFI C function from raylib._raylib_cffi.lib

`raylib.``MeshTangents`(mesh: Any)

  Compute mesh tangents

`raylib.``MinimizeWindow`()

  Set window state: minimized, if resizable (only PLATFORM_DESKTOP)

`raylib.``Model`

`raylib.``ModelAnimation`

`raylib.``MouseButton`

`raylib.``MouseCursor`

`raylib.``Music`

`raylib.``NPATCH_NINE_PATCH`

`raylib.``NPATCH_THREE_PATCH_HORIZONTAL`

`raylib.``NPATCH_THREE_PATCH_VERTICAL`

`raylib.``NPatchInfo`

`raylib.``NPatchLayout`

`raylib.``OpenURL`(url: str)

  Open URL with default system browser (if available)

`raylib.``PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT1_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_DXT1_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT3_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_DXT5_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ETC1_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA`

`raylib.``PIXELFORMAT_COMPRESSED_ETC2_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_PVRT_RGB`

`raylib.``PIXELFORMAT_COMPRESSED_PVRT_RGBA`

`raylib.``PIXELFORMAT_UNCOMPRESSED_GRAYSCALE`

`raylib.``PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32G32B32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R32G32B32A32`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R4G4B4A4`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R5G5B5A1`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R5G6B5`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R8G8B8`

`raylib.``PIXELFORMAT_UNCOMPRESSED_R8G8B8A8`

`raylib.``PauseAudioStream`(stream: AudioStream)

  Pause audio stream

`raylib.``PauseMusicStream`(music: Music)

  Pause music playing

`raylib.``PauseSound`(sound: Sound)

  Pause a sound

`raylib.``PixelFormat`

`raylib.``PlayAudioStream`(stream: AudioStream)

  Play audio stream

`raylib.``PlayMusicStream`(music: Music)

  Start music playing

`raylib.``PlaySound`(sound: Sound)

  Play a sound

`raylib.``PlaySoundMulti`(sound: Sound)

  Play a sound (using multichannel buffer pool)

`raylib.``Quaternion`

`raylib.``Ray`

`raylib.``RayHitInfo`

`raylib.``Rectangle`

`raylib.``RenderTexture`

`raylib.``RenderTexture2D`

`raylib.``RestoreWindow`()

  Set window state: not minimized/maximized (only PLATFORM_DESKTOP)

`raylib.``ResumeAudioStream`(stream: AudioStream)

  Resume audio stream

`raylib.``ResumeMusicStream`(music: Music)

  Resume playing paused music

`raylib.``ResumeSound`(sound: Sound)

  Resume a paused sound

`raylib.``SHADER_LOC_COLOR_AMBIENT`

`raylib.``SHADER_LOC_COLOR_DIFFUSE`

`raylib.``SHADER_LOC_COLOR_SPECULAR`

`raylib.``SHADER_LOC_MAP_ALBEDO`

`raylib.``SHADER_LOC_MAP_BRDF`

`raylib.``SHADER_LOC_MAP_CUBEMAP`

`raylib.``SHADER_LOC_MAP_DIFFUSE`

`raylib.``SHADER_LOC_MAP_EMISSION`

`raylib.``SHADER_LOC_MAP_HEIGHT`

`raylib.``SHADER_LOC_MAP_IRRADIANCE`

`raylib.``SHADER_LOC_MAP_METALNESS`

`raylib.``SHADER_LOC_MAP_NORMAL`

`raylib.``SHADER_LOC_MAP_OCCLUSION`

`raylib.``SHADER_LOC_MAP_PREFILTER`

`raylib.``SHADER_LOC_MAP_ROUGHNESS`

`raylib.``SHADER_LOC_MAP_SPECULAR`

`raylib.``SHADER_LOC_MATRIX_MODEL`

`raylib.``SHADER_LOC_MATRIX_MVP`

`raylib.``SHADER_LOC_MATRIX_NORMAL`

`raylib.``SHADER_LOC_MATRIX_PROJECTION`

`raylib.``SHADER_LOC_MATRIX_VIEW`

`raylib.``SHADER_LOC_VECTOR_VIEW`

`raylib.``SHADER_LOC_VERTEX_COLOR`

`raylib.``SHADER_LOC_VERTEX_NORMAL`

`raylib.``SHADER_LOC_VERTEX_POSITION`

`raylib.``SHADER_LOC_VERTEX_TANGENT`

`raylib.``SHADER_LOC_VERTEX_TEXCOORD01`

`raylib.``SHADER_LOC_VERTEX_TEXCOORD02`

`raylib.``SHADER_UNIFORM_FLOAT`

`raylib.``SHADER_UNIFORM_INT`

`raylib.``SHADER_UNIFORM_IVEC2`

`raylib.``SHADER_UNIFORM_IVEC3`

`raylib.``SHADER_UNIFORM_IVEC4`

`raylib.``SHADER_UNIFORM_SAMPLER2D`

`raylib.``SHADER_UNIFORM_VEC2`

`raylib.``SHADER_UNIFORM_VEC3`

`raylib.``SHADER_UNIFORM_VEC4`

`raylib.``SaveFileData`(fileName: str, data: Any, bytesToWrite: int)

  Save data to file from byte array (write), returns true on success

`raylib.``SaveFileText`(fileName: str, text: str)

  Save text data to file (write), string must be ‘ 0’ terminated, returns true on success

`raylib.``SaveStorageValue`(position: int, value: int)

  Save integer value to storage file (to defined position), returns true on success

`raylib.``SetAudioStreamBufferSizeDefault`(size: int)

  Default size for new audio streams

`raylib.``SetAudioStreamPitch`(stream: AudioStream, pitch: float)

  Set pitch for audio stream (1.0 is base level)

`raylib.``SetAudioStreamVolume`(stream: AudioStream, volume: float)

  Set volume for audio stream (1.0 is max level)

`raylib.``SetCameraAltControl`(keyAlt: int)

  Set camera alt key to combine with mouse movement (free camera)

`raylib.``SetCameraMode`(camera: Camera3D, mode: int)

  Set camera mode (multiple camera modes available)

`raylib.``SetCameraMoveControls`(keyFront: int, keyBack: int, keyRight: int, keyLeft: int, keyUp: int, keyDown: int)

  Set camera move controls (1st person and 3rd person cameras)

`raylib.``SetCameraPanControl`(keyPan: int)

  Set camera pan key to combine with mouse movement (free camera)

`raylib.``SetCameraSmoothZoomControl`(keySmoothZoom: int)

  Set camera smooth zoom key to combine with mouse (free camera)

`raylib.``SetClipboardText`(text: str)

  Set clipboard text content

`raylib.``SetConfigFlags`(flags: int)

  Setup init configuration flags (view FLAGS)

`raylib.``SetExitKey`(key: int)

  Set a custom key to exit program (default is ESC)

`raylib.``SetGamepadMappings`(mappings: str)

  Set internal gamepad mappings (SDL_GameControllerDB)

`raylib.``SetGesturesEnabled`(flags: int)

  Enable a set of gestures using flags

`raylib.``SetMasterVolume`(volume: float)

  Set master volume (listener)

`raylib.``SetMaterialTexture`(material: Any, mapType: int, texture: Texture)

  Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR…)

`raylib.``SetModelMeshMaterial`(model: Any, meshId: int, materialId: int)

  Set material for a mesh

`raylib.``SetMouseCursor`(cursor: int)

  Set mouse cursor

`raylib.``SetMouseOffset`(offsetX: int, offsetY: int)

  Set mouse offset

`raylib.``SetMousePosition`(x: int, y: int)

  Set mouse position XY

`raylib.``SetMouseScale`(scaleX: float, scaleY: float)

  Set mouse scaling

`raylib.``SetMusicPitch`(music: Music, pitch: float)

  Set pitch for a music (1.0 is base level)

`raylib.``SetMusicVolume`(music: Music, volume: float)

  Set volume for music (1.0 is max level)

`raylib.``SetPixelColor`(dstPtr: Any, color: Color, format: int)

  Set color formatted into destination pixel pointer

`raylib.``SetShaderValue`(shader: Shader, locIndex: int, value: Any, uniformType: int)

  Set shader uniform value

`raylib.``SetShaderValueMatrix`(shader: Shader, locIndex: int, mat: Matrix)

  Set shader uniform value (matrix 4x4)

`raylib.``SetShaderValueTexture`(shader: Shader, locIndex: int, texture: Texture)

  Set shader uniform value for texture (sampler2d)

`raylib.``SetShaderValueV`(shader: Shader, locIndex: int, value: Any, uniformType: int, count: int)

  Set shader uniform value vector

`raylib.``SetShapesTexture`(texture: Texture, source: Rectangle)

  Set texture and rectangle to be used on shapes drawing

`raylib.``SetSoundPitch`(sound: Sound, pitch: float)

  Set pitch for a sound (1.0 is base level)

`raylib.``SetSoundVolume`(sound: Sound, volume: float)

  Set volume for a sound (1.0 is max level)

`raylib.``SetTargetFPS`(fps: int)

  Set target FPS (maximum)

`raylib.``SetTextureFilter`(texture: Texture, filter: int)

  Set texture scaling filter mode

`raylib.``SetTextureWrap`(texture: Texture, wrap: int)

  Set texture wrapping mode

`raylib.``SetTraceLogLevel`(logLevel: int)

  Set the current threshold (minimum) log level

`raylib.``SetWindowIcon`(image: Image)

  Set icon for window (only PLATFORM_DESKTOP)

`raylib.``SetWindowMinSize`(width: int, height: int)

  Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)

`raylib.``SetWindowMonitor`(monitor: int)

  Set monitor for the current window (fullscreen mode)

`raylib.``SetWindowPosition`(x: int, y: int)

  Set window position on screen (only PLATFORM_DESKTOP)

`raylib.``SetWindowSize`(width: int, height: int)

  Set window dimensions

`raylib.``SetWindowState`(flags: int)

  Set window configuration state using flags

`raylib.``SetWindowTitle`(title: str)

  Set title for window (only PLATFORM_DESKTOP)

`raylib.``Shader`

`raylib.``ShaderLocationIndex`

`raylib.``ShaderUniformDataType`

`raylib.``ShowCursor`()

  Shows cursor

`raylib.``Sound`

`raylib.``StopAudioStream`(stream: AudioStream)

  Stop audio stream

`raylib.``StopMusicStream`(music: Music)

  Stop music playing

`raylib.``StopSound`(sound: Sound)

  Stop playing a sound

`raylib.``StopSoundMulti`()

  Stop any sound playing (using multichannel buffer pool)

`raylib.``TEXTURE_FILTER_ANISOTROPIC_16X`

`raylib.``TEXTURE_FILTER_ANISOTROPIC_4X`

`raylib.``TEXTURE_FILTER_ANISOTROPIC_8X`

`raylib.``TEXTURE_FILTER_BILINEAR`

`raylib.``TEXTURE_FILTER_POINT`

`raylib.``TEXTURE_FILTER_TRILINEAR`

`raylib.``TEXTURE_WRAP_CLAMP`

`raylib.``TEXTURE_WRAP_MIRROR_CLAMP`

`raylib.``TEXTURE_WRAP_MIRROR_REPEAT`

`raylib.``TEXTURE_WRAP_REPEAT`

`raylib.``TakeScreenshot`(fileName: str)

  Takes a screenshot of current screen (filename extension defines format)

`raylib.``TextAppend`(text: str, append: str, position: Any)

  Append text at specific position and move cursor!

`raylib.``TextCopy`(dst: str, src: str)

  Copy one string to another, returns bytes copied

`raylib.``TextFindIndex`(text: str, find: str)

  Find first text occurrence within a string

`raylib.``TextFormat`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`raylib.``TextInsert`(text: str, insert: str, position: int)

  Insert text in a position (memory must be freed!)

`raylib.``TextIsEqual`(text1: str, text2: str)

  Check if two text string are equal

`raylib.``TextJoin`(textList: str, count: int, delimiter: str)

  Join text strings with delimiter

`raylib.``TextLength`(text: str)

  Get text length, checks for ‘ 0’ ending

`raylib.``TextReplace`(text: str, replace: str, by: str)

  Replace text string (memory must be freed!)

`raylib.``TextSplit`(text: str, delimiter: str, count: Any)

  Split text into multiple strings

`raylib.``TextSubtext`(text: str, position: int, length: int)

  Get a piece of a text string

`raylib.``TextToInteger`(text: str)

  Get integer value from text (negative values not supported)

`raylib.``TextToLower`(text: str)

  Get lower case version of provided string

`raylib.``TextToPascal`(text: str)

  Get Pascal case notation version of provided string

`raylib.``TextToUpper`(text: str)

  Get upper case version of provided string

`raylib.``TextToUtf8`(codepoints: Any, length: int)

  Encode text codepoint into utf8 text (memory must be freed!)

`raylib.``Texture`

`raylib.``Texture2D`

`raylib.``TextureCubemap`

`raylib.``TextureFilter`

`raylib.``TextureWrap`

`raylib.``ToggleFullscreen`()

  Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)

`raylib.``TraceLog`(*args)

  VARARG FUNCTION - MAY NOT BE SUPPORTED BY CFFI

`raylib.``TraceLogLevel`

`raylib.``Transform`

`raylib.``UnloadFileData`(data: str)

  Unload file data allocated by LoadFileData()

`raylib.``UnloadFileText`(text: str)

  Unload file text data allocated by LoadFileText()

`raylib.``UnloadFont`(font: Font)

  Unload Font from GPU memory (VRAM)

`raylib.``UnloadFontData`(chars: Any, charsCount: int)

  Unload font chars info data (RAM)

`raylib.``UnloadImage`(image: Image)

  Unload image from CPU memory (RAM)

`raylib.``UnloadImageColors`(colors: Any)

  Unload color data loaded with LoadImageColors()

`raylib.``UnloadImagePalette`(colors: Any)

  Unload colors palette loaded with LoadImagePalette()

`raylib.``UnloadMaterial`(material: Material)

  Unload material from GPU memory (VRAM)

`raylib.``UnloadMesh`(mesh: Mesh)

  Unload mesh data from CPU and GPU

`raylib.``UnloadModel`(model: Model)

  Unload model (including meshes) from memory (RAM and/or VRAM)

`raylib.``UnloadModelAnimation`(anim: ModelAnimation)

  Unload animation data

`raylib.``UnloadModelAnimations`(animations: Any, count: int)

  Unload animation array data

`raylib.``UnloadModelKeepMeshes`(model: Model)

  Unload model (but not meshes) from memory (RAM and/or VRAM)

`raylib.``UnloadMusicStream`(music: Music)

  Unload music stream

`raylib.``UnloadRenderTexture`(target: RenderTexture)

  Unload render texture from GPU memory (VRAM)

`raylib.``UnloadShader`(shader: Shader)

  Unload shader from GPU memory (VRAM)

`raylib.``UnloadSound`(sound: Sound)

  Unload sound

`raylib.``UnloadTexture`(texture: Texture)

  Unload texture from GPU memory (VRAM)

`raylib.``UnloadVrStereoConfig`(config: VrStereoConfig)

  Unload VR stereo config

`raylib.``UnloadWave`(wave: Wave)

  Unload wave data

`raylib.``UnloadWaveSamples`(samples: Any)

  Unload samples data loaded with LoadWaveSamples()

`raylib.``UpdateAudioStream`(stream: AudioStream, data: Any, samplesCount: int)

  Update audio stream buffers with data

`raylib.``UpdateCamera`(camera: Any)

  Update camera position for selected mode

`raylib.``UpdateMeshBuffer`(mesh: Mesh, index: int, data: Any, dataSize: int, offset: int)

  Update mesh vertex data in GPU for a specific buffer index

`raylib.``UpdateModelAnimation`(model: Model, anim: ModelAnimation, frame: int)

  Update model animation pose

`raylib.``UpdateMusicStream`(music: Music)

  Updates buffers for music streaming

`raylib.``UpdateSound`(sound: Sound, data: Any, samplesCount: int)

  Update sound buffer with new data

`raylib.``UpdateTexture`(texture: Texture, pixels: Any)

  Update GPU texture with new data

`raylib.``UpdateTextureRec`(texture: Texture, rec: Rectangle, pixels: Any)

  Update GPU texture rectangle with new data

`raylib.``UploadMesh`(mesh: Any, dynamic: bool)

  Upload mesh vertex data in GPU and provide VAO/VBO ids

`raylib.``Vector2`

`raylib.``Vector3`

`raylib.``Vector4`

`raylib.``VrDeviceInfo`

`raylib.``VrStereoConfig`

`raylib.``Wave`

`raylib.``WaveCopy`(wave: Wave)

  Copy a wave to a new wave

`raylib.``WaveCrop`(wave: Any, initSample: int, finalSample: int)

  Crop a wave to defined samples range

`raylib.``WaveFormat`(wave: Any, sampleRate: int, sampleSize: int, channels: int)

  Convert wave data to desired format

`raylib.``WindowShouldClose`()

  Check if KEY_ESCAPE pressed or Close icon pressed

`raylib.``rAudioBuffer`

class `raylib.``struct`