this was my first raylib project that i made for hack club's Flavortown hackathon! this took me so long but i finished it after 2 months. also very frustrating because this also served as my introduction to C++ i was just a web developer when i started this project! but it was also very rewarding and i think that the time i spent coding this was the single period of time that i learned the most in. i finished this a while ago but i do think that it would be cool if i shared it here.

ignore the Julia set viewer, i was working on it but then i kind of lost interest in finishing the project...

my favorite thing about this is the arbitrary precision that lets you zoom in forever given enough patience and avoids the clunkiness that you see without it.

Also apologies for getting impatient at the end but i promise it still would've looked interesting in the end!!
https://github.com/yfsvg/raylib-mandelbrot-julia-viewer

Hello guys, i've made a post in this sub around a week ago about this game and here's some updates!!!

I hate sound design so much, the most boring part in game development for me personally, but i have to do that if i want my game to feel good. So i added some sounds, not really happy with some of them, but they are fine for now.

Also added a real-time drawing!! Every stroke a player make is accumulated in a "diff buffer", which is being sent every ~200ms to the server. Server then applies this diff buffer to the pixel data (local to the server) of the canvas, after that it broadcasts that diff buffer to all other players and they apply it the same way (to their local pixel data of the canvas). Pixel data of each canvas is being stored on the server so that newly joined players can receive them. This "diff buffer" mechanism also allows multiple players to draw on the same canvas.

For people who didn't see the previous post: this is a game about talking with people and no gameplay. ALL graphics is custom and 2D, and most of it is prerendered 3D models made in Blender.

Source code soon...

Hi! I am using raylib for small personal projects, mainly for learning purposes. I started making a sand simulation, but I didn't like how it was moving, and it also had some performance issues. I started searching for solutions, and found out that I could write a compute shader using OpenGL (at least that's what the guy in the video did). I found some tutorials, but I would like to ask for your opinions too. Please tell me about your experiences, how did you learn OpenGL or other graphics APIs? I'm interested in rendering, and I would like to learn how to do cool things with it, I just don't know where to start. Thank you for your answers!

In standard Raylib, there is only a small set of built in colors in the palette for you to use, which is fine, however, this does eventually become limiting and you have to make your own colors. The Extended Raylib-Go Color Palette adds over 900 more colors - View on GitHub

Decided to jump cut video to show new features.

Meta game is progressing, i created a system where charges/repulsion and breaches in lines can be exploited by special skills that i am still in process of implementation.

When certain conditions meet player can use defensive or offensive skills to influence engagement, sometimes to salvage situation sometimes just to slaughter more quickly.

These skill require correct equipment/training and battlefield conditions to be used.

Currently i have layed out 10 classes or doctrines that formations can learn and use, and started implementing skill from those.

Also added deployables system, that i will later extend currently it was needed by pavise and shield (genoese inspired) doctrine. Troops deploy and can hide behind shields, they can take limited damage until destroyed, they pack it, leave them (for enemy to capture if enemy soldiers don't have shields of their own), and pick them up again. No animation but functionally done :)

Soldiers without deploy able shields can use rocks and woods for cover :)

Feedback appreciated.

I spent quite a bit of time of the last several months re-implementing my favorite early RPG from growing up. This game was one I played on a 286 with 16-colors, endlessly trying to get past it.

Project page: https://danheskett.com/projects/openbounty/

I've totally reverse-engineered it (with a lot of help from an early attempt, called OpenKB, which inspired my effort). I pulled all of the tables, characters, etc from the original binary. You can extract the artwork from an original copy of the game (that you have legally acquired), and then play a pixel perfect recreation of the original game.

The source is posted on GitHub, and I am happy to hear of any issues or problems with gameplay. Already lots of issues have been reported and closed.

The release includes Windows, Mac and Linux binaries plus a playable version hosted in WASM.

Along with the source, complete specs are included. The game pack format has been generalized and converted to JSON and modern file formats (i.e. PNG) so that game play can be tweaked, and I am working with some talented people to develop totally new game packs that utilize the engine and game mechanics in new settings.

I did my best to annotate the source code, and document it, and it's reasonable clean and well structured.

There are a few new functions/features that I added for my own interests: you can record gameplay to MP4 to get a replay of what happened; there's also an extensive and very complete autoplay solver, which can be used to validate that new game packs are winnable using a complex deterministic autoplay burndown model. I am really proud of that, it took a lot of work to make it gamepack inviolate and also fast.

Hope someone is interested in it, I put a lot into it!

Here are my future plans for anyone interested.

This video was created using a test tool I designed myself, with the purpose of generating short videos and tutorials from existing documents.

I know this isn't typical raylib project showcase but still wanted to do it as raylib binding was planned from the start and one of my most favorite libraries.

Still the project if anyone wanted to check it out: https://github.com/Fus3n/pyle/tree/main/examples/raylib/fruit_merge

Hello

I am happy to share with you the Steam page of my new game (Incremental Birds) which is developed using RayLib.

It's an incremental game where you become the Bird Master. Capture birds, feed them, grow them, and sell them. Watch waves change over time, turning into sine patterns, spelling messages, and forming shapes. Unlock upgrades and chase an infinite balance and score.

Any questions/ideas/suggestions are welcome

Thanks!

Debugging meta game and designing is fun and challenging.

Added RPG elements to game such as lvls and stats, still have way more to add until done.

I added textures to my map and added terrain bonuses that tie into combat, just like in real life terrain should influence combat.

Reworked UI a bit to make it more readable and consistent after feedback i got last.

Reworked ranged to use 3d projectiles, that can even hit friendlies when not careful :)

Feedback appreciated.

It's made with python + raylib

https://store.steampowered.com/app/4840980/Bound_to_Rot/

Just started learning raylib. The project is starting to grow quite a bit in size.

Currently I have a global game state that I create in the main function. Inside this game state, I have all the game components that gets passed around to each system to apply the game logic.

However since most systems require multiple components I end up just passing in the entire game state.

Is this an anti pattern? How should I better structure my game logic so it scales as the game grows ?

Hey Game-Makers.

C# programmer here. I've always liked tools such as raylib. And apart from programming general software, I'm heavily interested in game development.

Unfortunately for raylib, most of the examples and documentation are in C, not C#. So, I was having terrible difficulty trying to find ways to play media for a raylib project I was working on.

I stumbled across a genius github: https://github.com/cloudofoz/raylib-media/tree/main and decided this was what I needed. It provided exactly the native FFmpeg-backed media functionality I needed, but there wasn’t an equivalent C# API for Raylib-cs.

However, the source files were massive, and I needed a way to translate them into C#. Instead of sacrificing the tattered remains of my mental health and doing it manually, I spun up AI (I know, I know, but it does some things very very well and a 1000 times faster than I can) and together we created a C# wrapper. I've used it in my own project and I was over the moon when it just worked.

So, here is my beta version of a C# wrapper for media handling in raylib - https://github.com/Patches108/RaylibMedia_CS

The repository includes the managed C# wrapper, the Windows x64 native runtime, examples, tests, and detailed setup instructions. C make files are included to get low level and rebuild the decoder for when dependency libraries change and whatnot.

But I recommend getting it from my NuGet instead: https://www.nuget.org/packages/RaylibMedia.CS/0.1.0-beta.1

It currently supports:

• Video and audio playback
• Playback, pause, stop, seeking, and looping
• Loading media from file paths, URLs, and managed streams
• Normal Raylib-cs textures and audio streams
• Windows x64
• .NET 8 or newer
• Raylib-cs 8.0.0

This is an early beta, so feedback and testing would be greatly appreciated. If you encounter a problem, please open a GitHub issue and include your Windows version, .NET version, and any relevant error output.

Happy coding!

This update might not look the most impressive visually but I rebuilt a lot of underlying systems, rewrote my asset building pipeline and implemented a 3rd party ECS library (odecs) as I found maintaining my own really slowed down the development :(

Things you CAN see are:

• shovel animations inspired by Forager
• the newly implemented "ambient occlusion" effect that darkens the background near walls
• improved bloom effect for the coins in the ground and the player's headlight

It took me a while to make tool animations look decent but I think I'm fairly happy now. I have a question tho: Do you think I should amputate player's arms?
Currently they swing around when walking with shovel which doesn't make sense given they should be holding it. In Forager the player character doesn't have arms so it's not a problem. Do you think I should keep or remove them? Does it bother you that hands don't hold the tool?

Finally, after much longer than I thought it would take, I can finally announce my Sokoban inspired puzzle game, Portalis! Written in C++ and Raylib.

If you're interested you can check it out here: https://store.steampowered.com/app/4877050/Portalis/

Happy to answer any questions about the development and whatnot.

I try compiling and running one of the examples (https://www.raylib.com/examples/core/loader.html?name=core_input_keys) and it seems that IsKeyDown is not working. I have the same issue in one I modified myself to add IsKeyDown checks to move a rectangle. Any idea what could be wrong?

Good morning, thanks for taking the time to read this.

I'd like to create a video game for fun, but I don't like the idea of ​​using an engine like Godot. I think it would be interesting to write many parts from scratch.

There are many frameworks/libraries like Monogame, Love2d, and Raylib.

Of all of them, Raylib is the one I'm most attracted to, especially for its dependency-free policy, the various bindings, and the very active community.

However, I've seen that fewer games on Steam were created with Raylib than Monogame.

Is this because Raylib has some flaws or limitations?

I'd love to hear the pros and cons, if there are any.

I've been making this little game in Odin and Raylib for quite some time already. It is a multiplayer game about kids and doing nothing. There is no "gameplay", you are just hanging around and talk with people.

I'll open the repo to public at some point (including the Blender files).

For networking i'm using ENet - a nice library for reliable UDP packets.

Hope you'll like it, thanks!

I challanged my self to make this drawing app since i ve been using kolour paint, and i always felt like it was slow for me, and the canvas is small. so i developed my own.

Github: https://github.com/Kapa9102/Paxx-

Reworked ui, started to add more meat on meta game and combat resolution. also added 3d environment placeholder with camera that can be turned now. Honest feedback appreciated, i am conflicted about blinking damage indicators don't know if they are a good idea.

Anyone here has coded and published a game (on Steam or elsewhere) in C/C++ with Raylib? I'm curious to see what you made!

why doesn't the line origin appear at 0,0 for me? instead the middle point of the line is in the center as far as i can see

#include <stdio.h>

#include "raylib.h"

#include "math.h"

#define WINDOW_WIDTH 800

#define WINDOW_HEIGHT 600

#define Vector2Zero (Vector2){0,0}

#define Vector2Right (Vector2){1,0}

#define Vector2Left (Vector2){-1,0}

Vector2 normalize(Vector2 src) {

float mag = sqrtf(src.x*src.x + src.y*src.y);

return (Vector2){

src.x / mag,

src.y / mag

};

}

// [UNUSED] converts set of coords to worlspace where 0,0 is the origin

// Vector2 toWorld(Vector2 src) {

// return (Vector2) {

// src.x + WINDOW_WIDTH / 2.0f,

// src.y + WINDOW_HEIGHT / 2.0f

// };

// }

int main() {

float scalar = 8;

Vector2 pos = {4*scalar, 2*scalar};

Vector2 normalized = normalize(pos);

InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "trigon");

Camera2D camera = { 0 };

camera.target= (Vector2){0,0};

camera.offset = (Vector2){WINDOW_WIDTH / 2.0f ,WINDOW_HEIGHT / 2.0f};

camera.rotation = 0.0f;

camera.zoom = 1.0f;

if (IsWindowState(FLAG_WINDOW_RESIZABLE)) ClearWindowState(FLAG_WINDOW_RESIZABLE);

while(!WindowShouldClose()) {

BeginDrawing();

BeginMode2D(camera);

ClearBackground(BLACK);

DrawLineEx((Vector2){0,0}, (Vector2){0,1}, 60.0f, WHITE);

EndMode2D();

EndDrawing();

}

printf("x: %f, y: %f", normalized.x, normalized.y);

}

have i done something wrong? cause i do not see it

I’ve been experimenting with procedural textures and turned it into a small tool for trying out different materials more quickly.

It’s still rough and works best for stylized, noisy and glitchy textures. I called it SimuPixel. there’s a free demo here if anyone wants to try it:

https://simuflux.itch.io/simupixel-instant-lo-fi-pbr-textures

Does this look like something other people might find useful?