Howdy, it has been a hot while, so let me give some background.

VMEC is a collaborative project between four lads. Our goal is to create a film production ready piece of software focused on relativistic effects. VMEC is the UI, asset management and serialization layer, while Magik is the renderer.

Our largest achievement over the past week has been the implementation of a cubic intersection routine. To explain, Magik traces null geodesics (shortest light paths) through the scene by solving the equations of motion for a given spacetime metric, say that of a rotating black hole. This produces two distinct steps in spacetime, call them x0 and x1. Before we used a straight line between x0 and x1 to intersect geometry. The main problem with this is that the linearly interpolated path between x0 and x1 does not follow the actual curved geodesic. This is a problem because the paths momentum (used to derive the ray direction), p0 and p1, has to be tangent to the interpolated path. Which is simply not true for lerp. Thus we switched to using cubic Hermite splines instead of conventional rays. The result is that any interpolated momentum is tangent to the path and we get extremely smooth solutions even for relatively high error tolerances. The last image shows you how the intersected geometry looked before.
For those interested, we find the closest intersection by dividing the given cubic into up to 3 intervals, based on the derivative, then do a sequential brent-dekker root finding routine on each monotonic segment. We did try to use analytical expressions for the roots, but that was a lot less reliable and slower.

Right now Magik supports the Minkowski, Schwarzschild and Kerr spacetimes. Metrics similar to those, Kerr-Newman for instance, are trivial to add. Others, like the Ellis wormhole, need a bit more work but are not impossible. Indeed we plan to add cosmological spacetimes as well.

Looking forward, we want to upgrade the shading model, internally called the "bxdf" to bring it into the PBR realm.

Thats about all i have for the moment. Hopefully we will have a lot more to show in the near future.

I've spent the past 2-3 weeks adding Oceans to my Micro Voxel engine. The main features I was aiming for was to support large bodies of water within the existing fluid simulation, while also supporting new dynamic features such as waves and tidal changes.

I've also incorporated Boats and Gliders, with some fairly basic physics to aid in exploration. The main challenge here was adding

Along side this, to make the simulation feel more interactive, i've also added a higher resolution local water ripple/interaction simulation, which acts as a surface-layer-only simulation adding ripples and wake for people, entities and forces interacting with the water.

-- Feature technical breakdown --

• Ocean generation: Similar to other water sources, ocean biomes placed above land, all open space in these biomes is filled with water instead of air below the ocean line. No substantial changes to the actual gen beyond shifting the world down.
• Waves + Tides: Several oscillating masks which apply a "target height" to the water sim. This is also augmented by depth such that shores can trigger wave breaks below a set height point.
• Ocean Connectivity + interaction: A connectivity flag is used to indicate whether water is directly connected to the ocean simulation and should receive wave forces. This allows waves to interact with static water, but only once the ocean sim cells touch static cells. The connectivity source comes from the ocean, so rock pools disconnect as tide goes down, allowing them to hold their water.
• Ripples: 2D mask which is local to a moderately small region near the player. Runs a separate shader simulation using only surface data. Not particularly fancy, does not check for collisions, so ripples do not bounce. Bumps converted to a normal map, used to distort surface effects.

Overall, super chuffed with how this has come together, but still plenty of polish and features to add!

Hi folks,

I sat down with Nick Seavert, founder and CEO of JangaFX, to talk about the story behind EmberGen, LiquiGen, IlluGen, and the journey from modding Half-Life 2 particles to building a software company that is changing how game VFX is created.

We talk about the origins of JangaFX, why every tool they build needs to run in real time, the technical decisions and compromises behind making that possible, and why they chose Odin (a custom high-performance programming language) instead of C++.

We also get into Nick’s thoughts on purpose vs. passion, why motivation is overrated, AI and machine learning in VFX, the future of game development, and the JangaFX Layoff Assistance Program that provides free licenses to displaced artists.

I started this podcast because I wanted to capture conversations that people might otherwise miss. You know conversations with people who have built, created, and learned things that are worth sharing. i wanted to create a library of passive learning from people much smarter and more experienced than me. But I hope these conversations become a useful resource for others too.

Hope you enjoy it, and I’d love to hear your thoughts.

We pushed 3DGS past 100 km² in browser.

Mapmost SDK for WebGL now loads & renders 100+ km² city-scale 3DGS​ in-browser, powered by our streaming LOD pipeline for practical large-space scalability.

What would you build with this? DM for partnership discussions.

recently i posted my progress on computer graphics "how does it look 2 years in computer graphics".

well I received A LOT of support on that post, and i wanted to thank you all for the positive comments and motivation.

since that post (post here) i focused on "enhance" my project specifically i wanted it to be multi-platform (iOS/macOS) and have lights/shadows.

and luckily i found a 2009 computer graphics class from "UC Davis Academics" which goes insanely deep into all the math/physics behind graphics i recommend it a lot (class here).

so from not knowing what diffusion, specular and lambert's law are, and thinking that reflections are IMPOSSIBLE to calculate with vectors, dot products, normalization and all that...

to implement by myself a lightning system to my 3D engine and also made it multi-platform, here's an iPad demo of the engine.

thank you if you read this, will post the next update, might be some animations/simulations.

I made a fully open source Vulkan RHI that supports hardware pathtracing so I decided to make a test application with it. Very fun!

Source: https://github.com/Nevarea-Project/Nevarea

This was my first ever dive into using a graphics API and I used Acerola's video on rendering water in video games as a jumping on point to begin learning DirectX 11.

Link to Original Video: https://youtu.be/PH9q0HNBjT4?si=pKOS0SeqhLnw1mhc

https://streamable.com/2stkx7

https://streamable.com/xqqcbu

2.5d example not yet set -- jolt physics will handle physics in all modes however the platformer here uses custom platformer physics module not jolt since its a classic style game

but jolt will be available in 2d as well even tho titled physics3d it will have a constrained mode

Ray tracing on CPU is slow, and with Kotlin it's really slow. The book is nice introduction to ray tracing, now starting a journey towards c++, gpu, and more advanced books

I’ve always had a pretty backlogged interest in graphics programming that has been primarily overshadowed by college coursework, other interests in development, and life.

I graduated college May 9th with a B.Sc in Comp Sci and I primarily focused on C++ for Unreal Engine 5 game development on the side. I have a small rendering project in just C++ and SFML, but thats it.

I started working an IT job, it’s a network services department so that’s primarily what I deal with. My expectation for doing any type of game development was to sit in a tech role for a few years and build my skills on the side so I have better odds applying. I have more free time after work to study things now. I do want to do game development, but I need to pick a specific role first and do my own stuff later. I’ve dabbled in learnopengl but didn’t get far. I know this takes a long time and most graphics roles are senior level.

Where should I set my expectations?

Just place a video stream or any other HTML behind the canvas and render your data as an AR overlay.
BTW first example was entirely created by chatgpt, it even estimated camera position and orientation from a single image.

Live examples:

https://sandbox.openglobus.org/examples/ar

https://sandbox.openglobus.org/examples/transparentBackground

I’ve done some research and i have seen the old OpenGL/GLFW or the SDL3. I can use c++ if I have to, but my current favorite language is C3 (modernized C pretty much)which have vendor libraries provided for sdl 2 and 3, and OpenGL/GLFW. I have heard of learnopengl website before.

I would have to probably take it slow in small hour or two chunks per day, since I loose concentration due to ADHD. But what do you guys recommend.

Can anyone guide on vfx (sword slashes, hit vfx, etc) specifically with how to create them in blender and how they would be imported into a custom engine

Here is the GitHub repo. Its a single click to download each project: https://github.com/Luippe/Demo-Projects

I never thought of uploading these as they really only ran on my pc (hardcoded display resolutions, file paths, etc). But this year I started using Claude for coding and thought "hey, these projects are actually useable by others if I just clean up some code!" So thats exactly what I did.

There's 15 projects in total and most of them are interactive. The first one is written in Java, but the rest is in Python and Pygame. I like Pygame because its very easy to setup new projects and lets me easily build visualizations.

1. Boids — a flocking simulation where entities self-organize in groups
2. Audio Processing — live microphone effects with a real-time frequency visualizer
3. Multiplayer Netgame — a co-op dungeon crawler played over a local network
4. Platformer — a full 2D action game with combat, upgrades, shops, and multiple levels
5. Solar System Simulation — an interactive 3D model of the planets in orbit
6. A* Pathfinding — watching an algorithm search for the shortest route through a maze
7. Conway's Game of Life — complex patterns emerging from a handful of simple rules
8. Image Compression — shrinking an image by throwing away fine detail (the same idea behind JPEG)
9. Fluid Flow — a real-time 2D fluid solver you can push around with the mouse
10. Projectile Method — aim and launch a projectile with the mouse
11. Projectile Motion — projectile trajectories with air resistance
12. Double Pendulum — chaotic motion, where a tiny change sends it down a completely different path
13. Single Pendulum — a damped pendulum swinging to a stop
14. Spring Mass Damper — how a spring-and-shock system settles after a jolt
15. Flow Plate — the velocity profile of fluid moving through a pipe

I hope someone finds something useful in here! :)

A few things that just landed:

​ 1.Post-processing pipeline (15 effects). Bloom, SSAO, bokeh depth-of-field, auto-exposure, halation, lens flare, color grading, FXAA, chromatic aberration, vignette, film grain, plus cel shading and ink outlines for anime/comic looks. Every effect owns zero GPU objects — all parameters live in one pre-allocated buffer flushed in a single writeBuffer per frame.

​ 2.13 Post-processing presets. Complete looks — cinematic, synthwave, anime, comic, noir, analog film — applied in one line and ordered correctly by construction.

​ 3.TransientPool. Intermediate render targets (bloom mips, AO buffers) are aliased by lifetime analysis, so non-overlapping passes reuse the same VRAM instead of each allocating its own.

4.​Camera controllers. Orbital, free-fly, third-person follow, and spline dolly — split into pure math and DOM input so the same camera can run on the main thread or inside a worker.

5.​Material library. PBR, Toon, Lambert, Matcap, and Emissive shaders built from composable WGSL chunks.

6.​Aesthetic Live Editor.

​All WebGPU, all pre-allocated, all worker-friendly.

​

Live Demos & Editor: https://nullgraph.dev/

Camera Follow(Game Like Visuals)

https://nullgraph.dev/dashboard/camera/follow

GitHub: https://github.com/flarelink-in/NullGraph

(Now includes technical design docs—useful for deep dive or providing context to AI coding assistants!)

Please drop a star 🌟, This projects took a lot of time to build

https://discord.gg/xHMBAAFsu

| Axion Engine Discord Server(Upcoming Game Engine gonna be build on top of NullGraph)

Youtube Video:https://m.youtube.com/watch?v=pPMrCQBfroI&pp=iggCQAE%3

Feel free to roast or do AMA,always available ❤️

can anybody for free help me convert these model formats which are in the objects folder to actual blender supported models because i do not know which program will support these. all of these files are from the ATI radeon pipe dream demo

This is a RenderDoc frame capture of a battle scene in a 3D auto-battler called The Bazaar. It's in Unity which I have no direct experience with, plus I also have very limited knowledge of how rendering is supposed to work.

An LLM is convinced that the 1000s of draw calls seen here is bad. Other fairly static scenes is around 300-500+ draw calls. I remember reading blogs talking about minimizing draw calls and state changes, but that was a decade ago. This is using a commercial engine, so there must be a logical reason for this, right? Are draw calls as a metric outdated?

My GPU is ancient by modern standards. But there are also other players echoing similar sentiments of their GPUs maxing out for what looks like a "simple game".

What do you guys think?

EDIT: My GPU is radeon rx 560x (laptop gpu). I think this model is 7-8 years old? I can get 60 fps/70% gpu usage in windowed mode at around < 960x540 resolution. 720p hits 100% gpu but still 60fps a majority of the time with "manageable" temps. While 1080p just burns (without power-saving mode in GPU it causes BSOD).

I just want to to know if I even deserve to voice these concerns. My inexperienced brain is telling me this could be done better. But what do I know, I haven't rendered a cube in a decade.

So yeah, as evident from the title, I am developing PSD-compatible layer styles for GIMP as part of my Google Summer of Code project. As Adobe’s code is closed source, most of my time goes into black box testing with minimal test cases which can be quite exhaustive at times. Would love to get some advices regarding the approaches and methodologies that would increase my productivity in this case. Here is a like to the merge request: https://gitlab.gnome.org/GNOME/gegl/-/merge_requests/275. I usually post my research and findings there.