How are solvers for these simulations even developed? Has anyone here ever used them? This is one is Magmasoft for reference

is it looks like snow?

does this subreddit have a discord server?

I was reading up on Newton for something I'm working on and realised nearly everything I could find was launch coverage or NVIDIA's own blog.

Barely anyone talking about actually using it. So I ended up going through the release notes myself.

If you haven't been following, the Newton physics engine hit 1.0 at GTC in March. It's the open-source engine NVIDIA built with DeepMind and Disney Research, and Isaac Lab 3.0 lets you swap it in as the physics backend instead of PhysX. MuJoCo Warp for rigid bodies, a separate solver for cables and cloth, and hydroelastic contact from Drake, which in theory should help a lot with insertion.

NVIDIA's number was 475x faster than MJX on manipulation. That was on their newest Blackwell workstation card though, so I'm not reading too much into it. The one independent benchmark I found (GPUSimBench, from July) didn't have a clear winner, it changed depending on the scenario.

What I actually found more interesting was the 1.1.0 changelog. A big chunk of it is import fixes. Mass and inertia, fixed joints, joint properties not parsing right between USD, URDF and MJCF.

Which kind of matters if the whole point is running one environment on different physics backends? If the inertia comes in slightly different on each one you've got a slightly different robot, and you probably won't notice until something doesn't transfer.

This is a problem we deal with at work. I'm at Rigyd, where we convert 3D models, Images and Text descriptions into simulation-ready USD and MJCF assets for Isaac Sim and MuJoCo, with the collision meshes, mass and inertia set up so the same asset behaves the same across engines.

So I'm biased toward thinking import is the bigger story than the speedup.

Skild is apparently using Newton for connector insertion and Samsung for cable handling with Lightwheel, but those are announced partnerships. I haven't seen anyone else write up switching over from PhysX.

So if you've tried it, did contact-heavy stuff actually transfer better or was it mostly faster? And how much did you have to retune assets that were already set up for PhysX?

Also if anyone's seen the same task run on PhysX and Newton with real robot results, please link it, would love to go through it

Hey guys, i’m currently building Timberline Factory...nearly 90% of the models are made by myself with Cinema 4D.. My main goal was to create an automation/tycoon game where logs aren’t just icons moving on a rail, but actual physical objects with weight and collisions... it was a complete nightmare to stabilize the physics so the conveyors don't explode during a log jam, and after rebuild the GUI the third time.. but it’s finally working fine :) If you’re into factory builders without "magic teleportation," the demo goes live on October 1st. Would love to get some feedback on the trailer :)

We have lots of physics simulations... right? Somewhere we have cloth, some fluid, softbody, smoke, vehicles, and celestial objects etc etc, but, these are not particularly one thing. We have these as different simulations and we use specific laws of physics for one particular simulation. Now... What if... maybe someday when get super complex computing power, could we simulate quantum itself, like literally how matter and energy came in, would rules of reality automatically apply and all laws of physics just work?

I have a casting simulation assignment to show reduction shrinkage defect in two weeks. Is there any way to do it fast and any software that help to do it faster this for assignment rights my three fourth of my entire semester mark

Hi everyone,

We build large rolling ball sculptures / kinetic marble runs and are trying to reduce the amount of physical trial and error involved in designing them.

Our current workflow is roughly:

**Concept → Sketch/CAD → Fabrication → Physical testing → Modify → Fabricate again**

For larger metal sculptures, these iterations can become expensive in terms of material, labour, and time.

We're exploring whether we can use **existing tools** to create a simple workflow like:

**CAD model → Physics simulation → Predict ball behaviour → Build physical prototype → Compare results**

We are **not looking to build a new physics engine or a large custom application**. The initial MVP would be very small:

* One standard ball
* One track/material system
* A simple mechanism, e.g. **ramp → loop → exit**
* Model it digitally
* Simulate the ball
* Build the same mechanism physically
* Compare the prediction with reality

The goal is not perfect simulation. We simply want to know whether a digital model can be accurate enough to catch obvious failures before fabricating larger installations.

Eventually, if this works, we would like to build a reusable library of tested components—ramps, loops, spirals, switches, collisions, etc.—with known parameters and behaviour.

We are currently considering tools such as **Rhino/Grasshopper** for parametric design and physics engines such as **MuJoCo, Project Chrono, Bullet**, or other alternatives.

**If you were approaching this problem using existing software, how would you do it?**

In particular, I'd love advice on:

1. Suitable CAD + physics simulation workflows
   
2. The best physics engines for rolling/contact dynamics
   
3. How to model and calibrate real-world friction and energy losses
   
4. Whether there are existing tools or projects we should investigate before building anything ourselves

We're very open to changing our approach and would appreciate any suggestions or warnings from people with experience in simulation, CAD, mechanical engineering, robotics, game physics, or kinetic sculpture.

Github Repo

I saw a particle life simulator in a Youtube video and I decided to try make one in Python (Then later Python and C), with the help of Claude (All the code is hand typed by me and most of it I came up with myself, Claude is only there to document libraries and things).

I'm happy with how it is, but I was wondering if anyone has made something like this before and how you made it more interesting than just a bunch of blobs moving around. I'm trying to read through some Github repos and stuff to see how other people make them, but I mainly just want to see some more interesting behaviours than these floating blobs.

Please note I am new-ish to computer programming. Any help or suggestions are appreciated. Thanks!

I'm currently trying to build a soft body physics engine for fun and I'm struggling on the collision detection part. So far it's almost there but I think there are a few edge cases that I must be missing because sometimes the bodies end up intersecting. I'm quite sure it's my CCD implementation and since I've never done CCD before and I'm not a computational physicist idk, how to fix it.

Here is what I have so far for my CCD Function

public static bool CCD(Vector2 P0, Vector2 vP, Vector2 A0, Vector2 vA, Vector2 B0, Vector2 vB, float dt, out float t, out float u, out Vector2 normal, out float normalSpeed)
{
    t = float.PositiveInfinity;
    u = float.PositiveInfinity;
    normal = default;
    normalSpeed = default;

    var vAP = vA - vP;
    var vBP = vB - vP;

    var vE = vBP - vAP;
    var E0 = B0 - A0;
    var D0 = P0 - A0;

    if (vE.LengthSquared() < Epsilon)
    {
        Vector2 n = new Vector2(-E0.Y, E0.X);

        if (n.LengthSquared() < Epsilon) n = -vP;
        if (n.LengthSquared() < Epsilon) return false;

        n.Normalize();

        float d0 = Vector2.Dot(P0 - A0, n);
        float vd = Vector2.Dot(vP - vA, n);

        if (MathF.Abs(vd) < Epsilon)
        {
            if (MathF.Abs(d0) < Epsilon)
            {
                t = 0;
            }
            else
            {
                return false;
            }
        }
        else
        {
            t = -d0 / vd;

            if (t < 0f - Epsilon || t > dt + Epsilon) return false;
        }
    }
    else
    {
        float a = -Geometry.Cross(vAP, vE);
        float b = Geometry.Cross(D0, vE) - Geometry.Cross(vAP, E0);
        float c = Geometry.Cross(D0, E0);

        if (Math.Abs(a) < Epsilon && Math.Abs(b) < Epsilon && Math.Abs(c) < Epsilon)
        {
            t = 0;
        }
        else if (SolveQuadratic(a, b, c, out float t1, out float t2))
        {
            var aT1 = A0 + (vA * t1);
            var bT1 = B0 + (vB * t1);
            var pT1 = P0 + (vP * t1);

            var edgeL1 = (aT1 - bT1).Length();
            var dist1 = (aT1 - pT1).Length();

            if (edgeL1 < 1e-2f && dist1 > 1e-3f) t1 = -1;

            var aT2 = A0 + (vA * t2);
            var bT2 = B0 + (vB * t2);
            var pT2 = P0 + (vP * t2);

            var edgeL2 = (aT2 - bT2).Length();
            var dist2 = (aT2 - pT2).Length();

            if (edgeL2 < 1e-2f && dist2 > 1e-3f) t2 = -1;

            if (!GetQuadraticSolution(t1, t2, 0f, dt, out t)) return false;
        }
        else return false;  
    }

    Vector2 P = P0 + (vP * t);
    Vector2 A = A0 + (vA * t);
    Vector2 B = B0 + (vB * t);

    Vector2 E = B - A;

    u = E.LengthSquared() == 0 ? 0f : Vector2.Dot(P - A, E) / Vector2.Dot(E, E);

    if (u >= 0 && u <= 1)
    {
        float uc = Math.Clamp(u, 0f, 1f);
        Vector2 vEdge = vA + (uc * (vB - vA));
        Vector2 vRel = vP - vEdge;

        if (u <= 0.0f || u >= 1.0f)
        {
            Vector2 endpoint = (u <= 0.5f) ? A : B;
            normal = P - endpoint;

            if (normal.LengthSquared() > Epsilon)
            {
                normal.Normalize();
            }
            else
            {
                if (vRel.LengthSquared() > Epsilon)
                    normal = Vector2.Normalize(-vRel);
                else
                    normal = Vector2.UnitY; // stable fallback
            }

            normalSpeed = Vector2.Dot(normal, vRel);
        }
        else
        {
            normal = new(-E.Y, E.X);
            normal.Normalize();

            normalSpeed = Vector2.Dot(normal, vRel);

            if (normalSpeed > 0)
            {
                normal = -normal;
                normalSpeed *= -1;
            }
        }

        return normalSpeed < 0;
    }

    return false;
}

And the functions it uses:

public static bool SolveQuadratic(float a, float b, float c, out float t1, out float t2)
{
    t1 = default;
    t2 = default;

    float eps = 1e-6f * (MathF.Abs(a) + MathF.Abs(b) + MathF.Abs(c));

    if (MathF.Abs(a) < eps)
    {
        if (MathF.Abs(b) < eps) return false;

        float t0 = -c / b;
        t1 = t0;
        t2 = t0;
        return true;
    }

    float disc = (b * b) - (4f * a * c);
    if (disc < 0f) return false;

    float sqrtDisc = MathF.Sqrt(disc);
    float inv = 1f / (2f * a);

    t1 = (-b - sqrtDisc) * inv;
    t2 = (-b + sqrtDisc) * inv;

    return true;
}

public static bool GetQuadraticSolution(float t1, float t2, float lowerBound, float upperBound, out float t, bool preferBiggest = false)
{
    t = default;

    if (preferBiggest) (t1, t2) = (t2, t1);

    if (t1 >= lowerBound && t1 <= upperBound)
    {
        t = Math.Clamp(t1, lowerBound, upperBound);
    }
    else if (t2 >= lowerBound && t2 <= upperBound)
    {
        t = Math.Clamp(t2, lowerBound, upperBound);
    }
    else
    {
        return false;
    }

    return true;
}

The main idea is that it uses the position and velocity data of a point and a segment to find the earliest time the point is on the segment and from that calculates a normal and a normalised position along the segment "u". This is then fed back to some other physics code to generate a response. I obviously still missing some edge cases, but I've been working on this for ages and can't get it to work properly. Does anyone have any advice or see any issues?

I'm new to EmberGen and I'm going through the documentation node by node. Regarding this "Loop Simulation" mode, this is all the manual says:

"Loop Simulation: Will try to turn the simulation into a loopable effect looping between the loop bounds visualized in pink in the graph editor. The loop bounds can be moved and extended using left mouse button dragging in the Timeline Editor. This option will expose the following parameters:

Blending Mode: Looping simulation is blending between 2 consecutive time intervals. 1st interval and 2nd interval allow you to see those intervals isolated, Dynamic Blend continues simulation after the inject, Static Blend is doing a simpler blend of the two intervals.

Blending Curve: Curve that is used to weigh the first and the second interval in the blend. Linear is recommended for Static Blend, Quintic is recommended for Dynamic Blend."

In the timeline, I can clearly see the pink range that indicates the loop, but besides that there is also some sort of pink marker moving inside this range, while the usual blue playhead keeps moving endlessly along the timeline.

The documentation mentions 2 intervals that are blended together, but within the pink range I can only define 1. How does the software determine the second interval, and how exactly do these 2 intervals form a loop?

Perhaps due to my current limited understanding of the system, I also don't understand what they mean by "Dynamic Blend continues simulation after the inject".

Would anyone with a better understanding of this feature be willing to clarify how it actually works under the hood?

For e.g. physics research, a perfect situation would be providing e.g. Lagrangian of model, and AI environment should generate code for simulations and run them presenting results - so we could literally talk with it regarding succeeding tests.

I know only one such environment: https://github.com/openwave-labs/openwave/blob/main/MODELS.md - are there any others?

How should such perfect tool look like?

Doing a "smoking candle" trend and trying to make the exhale look 100% real so it actually confuses people. I have a few variations and need a technical audit on the physics before the final render.

The smoke variations are labeled in this video: Smoke 1-6

• Smoke 1: Final (can't edit).
• Smoke 2, 3, 6: Currently in progress. Turbulence, shading, and speed are all adjustable.
• Smoke 2 & 3: Opacity and lighting are placeholders set for the screen recording (opacity was set high to be visible). Focusing on the fluid movemen. Lighting: These still need a lighting pass. These are the same sim but at different speeds (2 is slower, 3 is faster).
• Smoke 2-6 all can be edited further

Looking for feedback on:

1. Which option (1-6) has the most natural physics and "swirl"?
2. Any specific direction on color, shape, or volume to hit 100% realism?
3. Tips on mouth integration so it doesn't look like a digital overlay?
4. What would you change, like, or hate about these?

(High-quality renders coming once completed).

I tried looking on YouTube but couldn't find anything. I'm just looking for a simulation of what a natural waterfall would look like in lower gravity environments such as terraformed moons, so i can study what they may look like and draw them.

If you happen to know where I can find video of how fast rivers or creeks move in different gravities that would be nice to know as well.

Here’s a short clip from my life simulation game, Food Store Simulator.

In the game:

• NPC cashiers automatically handle checkout
• Deliveries arrive in boxes placed in front of the store

I’m experimenting with how much automation makes a simulation engaging.

Would you find this fun as a simulation, or would you prefer more player-driven interaction with the store operations?

I’d love to hear what aspects make a simulation feel alive and interactive to you.

Building an ocean simulation using the FFT method. This is suppose to be light stormy conditions, what do you think?

The end goal of this simulation is to train an ML on it to be able to simulate ocean moment itself, skipping all the complex physics calculations every frame. Which I would then like to implement into game development.

I work in VFX and only recently understood the full concept of Gaussian Splats. And yes.. I should know better. To me it was yes, it's a pointcloud with baked in data..

I had seen the demos and nodded along when people referred to it as "the next photogrammetry." However, if you had asked me to explain what they are precisely, their place in a real pipeline, or their capabilities, I would have struggled.

So, I took the time to understand it, and here’s the simplified version I wish I had received earlier

A Gaussian Splat consists of millions of tiny semi-transparent ellipsoids in 3D space. You input photos, train a model, and receive a scene in return. Phones serve as capture devices, and it can render at over 100 FPS in real time.

Key tools like Nuke 17 now include native support, Houdini 21 offers a tech preview, V-Ray 7 can ray-trace splats, and OpenUSD 26.03 has introduced a first-class schema. Notably, Framestore utilized 4D Gaussian splatting for approximately 40 final-pixel shots in Superman last year.

What it can achieve:
- Rapid and cost-effective capture of real environments
- Rendering at game-engine speeds
- Integration into compositing without the need to recreate the world in CG

What it cannot do:
- Relight scenes (yet)
- Provide a clean mesh (yet)
- Render with AOVs, as the lighting is baked into the data. This is the trade-off.

Thus, it does not replace photogrammetry or CG environments; rather, it serves as a new tool for scenarios requiring photoreal capture and real-time playback, with the understanding that relighting flexibility is sacrificed.

For fellow VFX artists who have been quietly nodding along: you are not behind. The foundational paper is from 2023, and most production tools have been released in the past six months. Now is the time to learn it before it becomes a part of your next project.

What new technology have you been struggling with? And if you have better simplified explanations I'd love to know!

Arvid

Guys, have anyone tried modeling foam ?

If so what are the governing equations for times delayed response. My goal is simulate load cycles faster than foam response.