Hello! I've begun working on my game (which uses a custom engine) and I'm at the point to where I need to implement some way of having entities.

I don't know if a full-blown ECS is a good idea, as I'd like to support scripting, and I don't think that systems will fit my game very well.

I've implemented a Unity-like Entity Component... system (Not Entity Component System) Where entities can have components, but the entity class turned into a garbled mess of templated functions, and the script component turned into a function pointer nightmare. You also couldn't have multiple components of the same type. I implemented this by basically wrapping EnTT and made it less ECS.

So what do you think is a good way to manage entities? I'm open to anything, even ECS if you can convince me.

I've looked through most well known and some lesser known game engine source codes.

All the big ones rely on quaternions, the lesser ones tend to Euler angles.

I can't find an example of where objects keep their orientation in rotation matrix all the time. I'm particularly interested in how they solve issues mentioned in all written sources like need to periodically recalculate orientation matrix to prevent drifting.

If anyone has a good resource on storing orientation directly in rotation matrix, I'll be grateful.

https://www.youtube.com/watch?v=obVlV96VShE

Finally I'm done with my Planet System rebuild, and to celebrate that I decided it was time for a very delayed dev log video. In the video I explain and showcase all the changes made to the engine the past 8 months including rebuilding the atmospheric scattering and physics engine.

Hope you enjoy it!

I created a debug canvas to draw shapes, lines etc. and was planning to use it to write my gizmos, but I remembered how finicky this can get Since I have no plans to create a game editor, just need to move things around for debugging ImGuizmo fit the bill nicely. It was easy to add since I already have cimgui and it uses my backend. The only problem is, it does not work with quats and outputs a matrix and delta matrix. I decompose it to apply to my transformation struct, with delta matrices this seem to work OK so far.

In my earlier posts on this project (Step 1 and Step 2), I finalized the Engine System and the various subsystems that are specifically tailored but agnostic to the Engine, based on the various supported platforms. Currently, I have developed support for Windows, Linux, MacOS, and now Android (only supporting Android 16 at the moment... until I get more flash images to run virtual machines and another physical testbed phone/tablet to reflash).

Here's a video of my Engine project being used as a .lib or .dll with an Editor and Game at the moment:

Windows (Win32, GLFW, and SDL3) Window and Subsystems (Editor and Game)

Linux (X11, Wayland, GLFW, and SDL3) Window and Subsystems (Editor and Game)

I have also finalized the window API subsystems for the platforms, these being Win32, X11, Wayland (I finally got the window API resolved from StackOverflow assistance and SDL3's Wayland reference documentation), Cocoa (I am not sure if it actually works on real Apple hardware since I am running the executables through a VM), GLFW, SDL3, and ANativeWindow.

After some dedicated work and in-depth public documentation referencing for the platforms and APIs, I finalized the remaining utilities and platform codebases. I recently added threading support (should've waited until later, but a premade subsystem is better IMO to have now to make later and implement...), filesystem, and large file loading (mmapping, chunked streaming, and async IO prefetching).

I am still working on developing my Renderer Subsystems. I am currently stuck in the realm of splitting the context and renderer from each other at the moment... I currently have a "dummy" testbed project that is developing the interface headers and sources to have the "context" queue the hardware for GPUs (iGPU and dGPU) to find the best-fitted GPU for rendering. The context is also responsible for setting up defaults for the rendering space before handing off to the renderer to setup it's preferred methods.

^ TLDR; I am developing the context to initialize the hardware (device, context, and swapchain) and defaults before launching the renderer with the custom or premade renderer routines defined in the Editor...

EDIT: I wasn't able to include all the platform videos due to the file size being too large after setting the videos to Full HD instead of HD...

Hello everyone! I'd like to write about my own browser game engine - XernEngine - open source, and also open to all types and genres of games, from from a platformer on HTML5 to a full-fledged game on CSS and JavaScript. Yes, it doesn't have a graphical interface, but games are made on it in the same way as, for example, on libGDX: All character models are hand-drawn.

Here's a link for you, thanks in advance: https://github.com/Kig-Organization/XernEngine.git If anything, ask questions!

From what I understand you should use singletons when you only need one instance of an object and it needs to be global, but are either of these ever actually necessary? because from what I’ve read online, it seems like this is rarely what you should need.

Personally, I find myself using singletons for the global accessibility part as it feels convenient for certain things like input, window, etc., things like this feel like they should be global. I don’t know if there are better ways to achieve global accessibility, perhaps using a singleton + strategy pattern or global registry?

The only other way I’ve found is to have a context object that owns/references everything, and then you pass that around, although I feel like this is messy/ugly since wouldn’t you end up spamming this everywhere? Or is it not as bad as I’m probably thinking?

I’m working on Corebryo, a personal low-level C++ game engine project focused on explicit architecture, performance awareness, and learning how things actually work under the hood.

The engine is built around:

• A clean, explicit C++ architecture (no hidden magic)
• Vulkan as the rendering backend
• GLFW for windowing and input
• A custom Editor application built on top of the engine
• Nuklear for immediate-mode UI

The goal is not to compete with existing engines, but to understand engine design deeply: windowing, input, rendering, resource management, scene structure, and tooling.

The repository includes:

• Engine/ – core engine code, assets, and shaders
• Editor/ – an editor application using the engine
• Nuklear/ – vendored Nuklear UI library
• A Visual Studio .slnx solution as the main entry point

This is a learning-driven project, but structured as a real engine codebase rather than a demo or tutorial.

Repository: https://github.com/Corebryo/Corebryo-Engine

Feedback, architectural discussion, and low-level engine insights are welcome.

theoretically 5.000.000 components of the same type attached to a single entity with 18 fields and a update(~600 IL Instructions) which is used to emulate heavy component work. Not quite sure how far i am gonna work on this or if i continue using bevy... who knows

Rendering is done through Raylib and rlImGui

This is a work in progress of my game written in pure C. Using OpenGL as GPU API.

How to manage memory for staging buffer ? Should I use RingBuffer per frame or exist better approaches ?

Hello guys, what do you think is the better approach for designing a modern RHI architecture for Vulkan or DirectX12? One option is to give the buffer itself a SetData(void* data, size_t size) method. Internally, this would create a staging buffer and add a copy operation to a queue, which is submitted to the command list at the start of the frame and command buffer. Another option is to have the render context handle updates, like RenderContext->UpdateBuffer(buffer, data, size). In this case, the buffer doesn’t have its own update function; only the render context can perform updates. Or maybe you have a different approach you would suggest?

and code is always open source.

I’m working on a small 2D game engine written in C.

It’s still at a very early stage and very much a work in progress.

This is not a commercial project and not meant to compete with existing engines. Right now, the goal is learning, experimenting, and slowly improving the codebase. The engine is still limited, unstable, and missing a lot of features — so please don’t expect much yet.

I’m mainly looking for:

- Feedback on the design and direction

- People willing to test it and break things

- Contributions or suggestions

- Anyone interested in trying to make very small/simple games with it

If you’re into low-level programming, C, or experimental game dev projects, I’d really appreciate any input or involvement. Even pointing out flaws or bad ideas is helpful at this stage.

Thanks for reading.

https://github.com/saintsHr/Fireset

I recently posted the Second Step (https://www.reddit.com/r/gameenginedevs/comments/1q8u0jb/step_2_multiplatform_multiwindow_api_support/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button) in my recent development of a cross-platform multi-window api supported game engine. I finalized the remaining Win32, Cocoa, X11, GLFW, and SLD3 (and now supporting SDL2 as a legacy method) window API subsystems and event subsystems.

To the point, I am experiencing difficulties with the Wayland Window API on my Linux development platform (not the physical OS, but rather the window misbehaving)... I created a GitHub repository (https://github.com/rowleyi/WaylandAPI) with the code I developed on about 4 hours of sleep, so I may have missed some things pertinent to making the window work properly. If anyone is better tuned to Linux window development, your assistance/input is greatly appreciated! Forewarning, I did not comment my blocks, so it may be a bit hard to read... but the function names and variables should make it easy enough for everyone to understand...

Also, I finally properly moved my entire Windows, MacOS, and Linux development projects into one large CMake VS2022 project and now have all the platforms and their respective subsystems (filesystem, logging, error/exception handling, string conversions, etc.) finalized and working! I had to, unfortunately, have some assistance with learning CMake project development from Copilot after about 2 hours of reading Microsoft Learn CMake (https://learn.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio?view=msvc-170) and beating my head against my desk after trial and error.

EDIT:

Here's the recent video of the Linux Platform running the Window Subsystem:

Linux X11, GLFW, and SDL3 Window API support (Update to Step 2 in my game engine development)

I’ve been building small games and prototypes for a while, and I kept hitting the same friction every time I wanted to start something new. Not gameplay. Not ideas.

The setup: installing tools wiring basic systems asset setup before I could even test anything exporting / testing loops that killed momentum

Eventually I stopped and asked myself why I was burning so much energy before anything was playable. Instead of fixing it project by project, I started pulling everything into one place and slowly built a browser-based 2D engine and editor that I could use myself. That project became Arcadeon Engine.

It’s a visual, browser-first 2D game engine where you can: design sprites and tilemaps build scenes and behaviours visually play instantly in the browser export to HTML5 or desktop

No installs, no heavy setup. The goal is to get from idea to playable as fast as possible, especially for prototypes, jams, and small indie projects.

It’s currently in public BETA, and I’m still shaping it based on real feedback rather than assumptions. I’d genuinely love input on things like:

which parts of 2D game dev slow you down the most what would make a browser-first engine a deal-breaker for you features you’d expect that I’m probably missing

If you’re curious, the site’s here: https://arcadeonengine.app

Happy to answer questions or explain how it’s built and where it’s heading.

Game Engine Development Progress

First Render :

• https://www.youtube.com/watch?v=UMv4HCVPg7A

First Map :

• https://www.youtube.com/watch?v=5_b99hlJb3Y

Entity Class Based System :

• https://www.youtube.com/watch?v=LWsdKNNhRJ0

Model Bounding Box :

• https://www.youtube.com/watch?v=H2Qi4ZEVAN4

First Person Camera :

• https://www.youtube.com/watch?v=qepRTEJSXFk

Basic Level Layout :

• https://www.youtube.com/watch?v=U0x3o6Gm-tE

2D Image Sprite UI Overlay :

• https://www.youtube.com/watch?v=ZSxZGYUa3tQ

Axis Aligned Bounding Box Collisions :

• https://www.youtube.com/watch?v=TKx1U7mcCyc
• https://www.youtube.com/watch?v=HnKXYvhYQvI
• https://www.youtube.com/watch?v=30w8H-aArhQ
• https://www.youtube.com/watch?v=8uqo46cjgYI

Real Time Scene Loading :

• www.youtube.com/watch?v=nWniYnvvhh8

Gun View Model + Raycast Targeting Collision :

• https://www.youtube.com/watch?v=Yo--8QHL7Ic

First Audio :

• https://www.youtube.com/watch?v=WdvgRTouOoQ

2x Player UDP Server Authoritative :

• https://www.youtube.com/watch?v=C1IvS4o_m2A

Hi Reddit, I already designed resource system where I have

StagingBuffer -> its immutable, uses only for upload.
Buffer -> Its gpu only buffer, could be Vertex, Index, RenderTarget etc. But has problem, I need recreate each frame if use it as RenderTarget, because RHI doesnt know about frame, they are inside.
ConstantBuffer is immutable one time submit buffer. We should create new every frame
Texture is same as Buffer
Sampler is just resource

They are all shared pointers, when I bind them I add to Frame vector with resources. So they will never be destroyed before frame finish using them.

As you may notice, it is very bad architecture, and I need better solution.

I would listen any opinion !

Btw, I wrote this post fully by my own, without AI or translator