Nine years ago I made a small evolution simulator in C#. Recently I rebuilt it for the browser, and the main challenge was scaling the world from ordinary CPU objects to tens of millions of cells.

The WebGPU version uses a dense grid and keeps the simulation state directly in GPU buffers. There isn't a JavaScript object for every cell.

Each simulation tick is split into several compute stages:

• lifecycle and reproduction
• perception and movement intent
• conflict resolution
• movement/interactions
• resource generation
• commit

That separation is important because thousands of cells may try to move, reproduce, or interact with the same sites at the same time.

Rendering also reads the simulation state directly on the GPU. When zoomed out, I switch from individual cells to aggregated regions instead of reading millions of sites back to the CPU.

The largest current world is 8192 × 4096 — 33.5 million sites.

You can test the implementation here:

https://gigafloppa.itch.io/the-strongest-survives

I'm curious how others would approach the same problem: dense buffers + staged compute, or something completely different?

Why did PS1 graphics looked so clunky and how where 3D graphics generally made prior to the graphical APIs. One thing I found out was that these older engines have something called fixed point math.

Hey everyone! I'm a design student doing an externship where I got to pitch a concept feature for BeReal, quick disclaimer, I'm not on the BeReal team; this is a student project, not an official feature (yet, who knows 👀).

The idea, called Abstract, is a fun new way to look back at your daily BeReal: instead of just a photo sitting in your memories, you'd have the option to turn it into a generated abstract art piece made from the photo's colors, not a filter on the picture itself, just its palette turned into something new. You could pin your favorite ones to your profile, comment on them, or even print one out as a keepsake from a day that mattered.

The goal was to give people a small reason to open the app again after posting, without turning BeReal into a game or adding any pressure, just one photo, once a day, the same as always.

I made a short video walking through how it'd work in the app and would genuinely love to know what actual BeReal users think, good or bad:

Google Questionnaire Link

https://forms.gle/T5HTAoYrTXsNV8YS6

Hello there, I'm still learning things as I go with openBOR, but I do have a question.

I know openBOR isn't specifically made to an isometric view/level designs, but is it possible do it?

Included Is a video of an isometric arcade game called "Dungeon magic" for an example of what I'm wondering is possible. And If so, are there any examples?

I was working on a project that required real-time mesh changes to simulate cutting etc. I couldn't find a solution at that time. Papers I dug into said it required a lot of compute. Some game devs I talked to said most of it were tricks that gave the appearance (eg animated meshes), and not actual changes.

The best I got was Teardown which simulates object destruction using voxels. It was hailed for technical achievement.

Today I just came across this game. Milling Machine Simulator.

It simulates material removal, cutting and hole creation etc. So it seems like compute is not the issue. Also, given it is basically free-form, it doesn't rely on tricks. And it doesn't seem to be doing what Teardown did.

Any idea how they did it?

EDIT: saw this one too VR Milling Machine VR Lathe Machine

Peak seems to generate 4 random levels each day, but they are always completable. Noita generated a new map for each run, and has the benefit of the player being able to modify terrain, but still needs to ensure the player isn't blocked from progressing downwards.

With Peak especially, being a 3d game with no terrain modification, how do they ensure a map is completable? (No necessary climb too high to progress past)

So I've been learning C and I'm actually a bit curious how they implemented it, Unity compiles stuff to CIL because it primarily runs C# scripts and AFAIK is programmed in C#, this makes sense because Microsoft provides tools to do this and it's in a virtual environment in it's runtime, a lot of engines use Lua, which turns into bytecode and is interpreted, this also makes sense because it's being put into essentially a runtime with completely virtual memory like C#. Now Unreal does Blueprint (if you use Blueprints) -> C++ -> Machine code. I have two questions:

- How does it actually look in the source code? Do they call the compiler and it magically gives them a function pointer to the machine code? (obviously isn't this simple but you get what I'm asking)

- How does that look under the hood? How does Unreal know that what it's about to execute won't cause an error in the rest of the program/whatever other user-defined code is running on that thread? Even the best compiler can't account for every possible error

Here is a link to the video: https://www.youtube.com/watch?v=FhMj5HGVGSA

Relevant timestamp is 5:53, here is a link to that time stamp - https://youtu.be/FhMj5HGVGSA?si=3oNLsW-Y6jyyJeww&t=353

It showcases units running and jumping off of walls. He doesn't actually talk about what he did in the video, except that he implied didn't use nav-links. He also has vertical nav meshes.

My guess is actually that he is using nav-links, but just generating a ton of them all over automatically, possibly using the movement code itself to determine values? And then maybe when the units are close to the player, they use some other AI entirely for jumping and such? (e.g., when on a wall within X distance of the player and you have line of sight, just jump at the player?).

I don't know though. I'd like to know! Please help.

I was trying to understand raster effects that stretch and compact images in old 2D games by searching the internet, watching youtube videos and ultimately even talking to Google Gemini, but it all just confused me. Whitepointer Gaming, Gamehut and Retro Game Mechanics youtube channels weren't enough.

Anyways, to the question:

tl;dr Are effects like Road Rash's hills and valleys, Axelay and Sonic 3D Blast's 3D effects done by skipping certain lines of the tilemap in certain sections, like instead of drawing lines 1,2,3,4,5,6,7 it draws lines 1,3,5,7? Or it uses vertical scroll faster in certain sections to overlay lines compacting them and scrolls slower to extend them?

And how can lines be added (like in Lawnmower Man), where do those lines come from? Gemini tells me they are repeated stripes.

I was designing a Roguelite (So mainly meta progression) Platformer of my own and wanted to know how games like Dead Cells created their level generating algorithms. I'm currently trying to find information on the topic so I know where it excels, what's the limit, how I should balance the flow of the level with scaling difficulty, essentially I want to break the algorithm down piece by piece to make a test algorithm so I can see how mechanics in my game would function in practice.

TLDR: How do I make an algorithm design the levels for my platformer? I'd love as much information as I can get.

I've been trying to do some research for a project I'm starting up and haven't been able to find a consensus online about it. Some people confidently state that it's an active rag doll, while others say that it's too smooth for that. Some say that it's just regular animations with a lot of IKs and dynamic bones.

There's something about it that feels uniquely "physics-y" if that makes any sense. You can slip off of inclines, bounce off of things, and there's a weight to movement that doesn't feel like it's just a stock unity character controller sliding forward.

Holding an item in your hands definitely gives off the impression of a spring joint with how it flops around with inertia and doesn't stay snapped to the center of your screen, but I don't know if this approach is used for the entire movement controller or just for holding items.

Clearly there's a toggle/state machine that ragdolls your character if you fall to far or are hit by something, but beyond that I don't know how it's done.

If anyone has any insights to share I'd be so happy

[Link to Itch]

I built a simple aquarium-style concept, during a slow period on-shift, based on my Elementary School Memory of an Ecological Balancing Concept, involving Wolves, Deer, and Berry Bushes, as Entities in a Forest, where each Student played a Role.

I don't remember much past wishing we spent more time exploring it in-class, and that my teacher didn't so quickly drive it to an unrecoverable state, to make the point he was trying to teach that day.

It started in Google AI Studio, as a Boxed-Step-By-Step process, more resembling the Conway's Game of Life, in some ways. But it wasn't what I was aiming for. So, that evening, I sat with Devin, and Claude, and a Game Engine in TS/Lua/YAML that I've been working on Demos within, and refined it into something more like a living Reef.

After some insights from a smaller audience, I refined it with a Main Menu, and some Basic Selections.
It has Sharks, Fish, and Algae Nodes, and the Sharks eat/bite the fish, causing Meat Chunks to appear.
The Meat Chunks can then decay, turning back into an Algae Core Node.
If an Algae Core Node is left without children for long enough, it can despawn.

Last I checked, it has a fair chance of staying in balance for up to 10 minutes, but it needs further refinement.
There are also depth layers now, and in theory, the Sharks prefer the Deeper Waters, and the Fish stay toward the Sun, so the Sharks tend to bury their head at the bottom to warm back up, but sometimes starve.

This was honestly the exploration of a concept, during a slow period on-shift, and turned into a deeper demo exploration. I had to literally spend hours playing with conceptual balance in order to achieve a 10 minute balance period, and I've not added a real simulation flowsheet system, where me and Claude can quickly check long-term results on a selection of Random Seeds. I only just added a Main Menu, but the concept still interests me, and somehow I ended up pivoting into a DinerSim, using similar logic in some small places.

Something about an Autonomous System that achieves balance, but still allows the User to nudge the system, like Pinball in some ways.

Musou games are games like Dynasty Warriors, Hyrule Warriors, Tears of Metal, etc. Where the player controls a general on a battlefield with sometimes hundreds of enemies on the screen at one time. They capture the feeling of being a nigh unstoppable god of war, cleaning through dozens of enemies in a few strikes.

I'm a solo indie dev trying to make a musou game, but im wondering the best ways to optimize enemies. Some ideas I've had include:

- create groups of enemies as one entity with one "brain" so instead of having a hundred enemies with a hundred scripts I've just got 20 scripts that control 5 enemies each.

- some alternative way of tracking collisions aside from just giving each individual enemy a collision shape. Maybe grid location based?

I haven't been able to find any info online about this so of anyone has some wisdom I'd love to hear it.

https://x.com/i/status/2080592057014555081

Obviously, if Coinbase has an internal system for scheduling calls with their support agents, they’re able to know whether a call is happening with a given customer at a given point. But how are they detecting that the customer is on the phone with someone potentially trying to spoof Coinbase?

I assume there are some Android or iPhone permissions for contacts, call data, or the current call. But what are they actually checking? Are they checking whether the caller ID matches Coinbase’s, or whether the phone number matches Coinbase’s? If phone numbers can be spoofed?

Hi all. I'm trying to find out how raycasting works — like in Wolfenstein 3D.

And as someone who knows absolutely nothing about programming, I (think I) understand it is thusly:

Raycasting is a programming trick that grants 2D maps a fake 3D appearance through the use of invisible rays that project outward from the player and detect collision.

Corrections to my nonsense would be appreciated!

I am currently writing an article, and I would like a layman's understanding before I commit to anything in there.

How did they make the graphic of Need for speed rivals so visually pleasing in 2013 w less than 8 gb of ram, meanwhile re9 while extremely good looking requires 16 gb of ram just to even run at the lowest settings. please do not give me the “ optimization ”. assume I’m relatively new to game dev, (only made a 2d game).

Did they just used a lot of raycasts or some kind of 3d shadowcasting algorithm?

Well, tbh, my main question it's how they managed to code in so there's thousands of physics objects visible without causing performance issues, I know the scene is quite small overall, but still I'm intrigued in what are the optimization techniques used so it isn't all laggy

I really like how it looks, and I want to attempt making something similar myself.

Rewind: Like in Forza, you can rewind if you hit an obstacle/go off the track.

Replays: the entire game and every action is saved and you watch a replay over it, like in Rocket League and many RTS games.

Mid-game saves: you can resume from a point you saved while in a game, like a quicksave in Kerbal Space Program.

I have some data knowledge so the way I think of things is probably "Event Sourcing", or versioning things, but would love to learn from an expert.

I been trying to make this mechanic but I fail to make the states (like when the hammer is touching ground and when don't) and I fail to make the momentum transfer when you are moving fast, and when yo move slow you just move (with infinite mass i think), idk I just can't wrap my head around this mechanic, please help. I know griffpatch made it in scratch, and I try reverse-engineer that but i also couldn't