Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

1/N Introducing🌈PRISM-Physics, a process-level, rule-based benchmark for complex physics reasoning. Each solution is modeled as a Directed Acyclic Graph of formulas, capturing causal relations between steps. A rule-based symbolic equivalence checker ensures consistent evaluation

WanjiaZhao1203's profile picture

Wanjia Zhao

1,378 subscribers

56,364 Aufrufe • vor 8 Monaten •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

0 Kommentare

Keine Kommentare verfügbar

Kommentare vom Original-Post werden hier angezeigt

Ähnliche Videos

I taught an LLM to optimize proteins. It proposed a better carbon capture enzyme. Introducing Pro-1, an 8b param reasoning model trained using GRPO towards a physics based reward function for protein stability. It takes in a protein sequence + text description + previous experimental results, reasons over the information given in natural language, and proposes modifications to improve the stability of the given sequence. 🧵(1/n)
0:27

I taught an LLM to optimize proteins. It proposed a better carbon capture enzyme. Introducing Pro-1, an 8b param reasoning model trained using GRPO towards a physics based reward function for protein stability. It takes in a protein sequence + text description + previous experimental results, reasons over the information given in natural language, and proposes modifications to improve the stability of the given sequence. 🧵(1/n)

Michael Hla

313,048 Aufrufe • vor 1 Jahr

Elon Musk on learning physics: What matters are not the formulas, but the thinking process that led to the discovery of those formulas. “I just recommend studying physics. What matters is not remembering a bunch of formulas. What matters is the thinking process that led to the discovery of those formulas. It's sort of critical thinking, first principles analysis, trying to understand what is true at a most fundamental level and then reasoning up from there and testing your conclusions against the most fundamental truths in any given arena. This is how you can figure out whether something is more likely to be true or not. It's good to think in terms of probabilities. If you receive information about a subject, that should change the probability of your conclusion, but not the certainty of your conclusion. Physics teaches you that you should not be 100% certain about any given prediction. Now, there's some things that are highly likely, but physics teaches you you got to assign a probability to something being true. And then as you learn more information, your original conclusion may be wrong, then you should then change your mind based on the new information.” Town Hall in Lancaster, Pennsylvania, October 24, 2024
1:01

Elon Musk on learning physics: What matters are not the formulas, but the thinking process that led to the discovery of those formulas. “I just recommend studying physics. What matters is not remembering a bunch of formulas. What matters is the thinking process that led to the discovery of those formulas. It's sort of critical thinking, first principles analysis, trying to understand what is true at a most fundamental level and then reasoning up from there and testing your conclusions against the most fundamental truths in any given arena. This is how you can figure out whether something is more likely to be true or not. It's good to think in terms of probabilities. If you receive information about a subject, that should change the probability of your conclusion, but not the certainty of your conclusion. Physics teaches you that you should not be 100% certain about any given prediction. Now, there's some things that are highly likely, but physics teaches you you got to assign a probability to something being true. And then as you learn more information, your original conclusion may be wrong, then you should then change your mind based on the new information.” Town Hall in Lancaster, Pennsylvania, October 24, 2024

ELON CLIPS

67,501 Aufrufe • vor 5 Monaten

If any agreements reached or to be reached between Beijing and Washington serve the interests of our Chinese friends, we welcome them. However, we will not take part in games based on a “divide and rule” approach. As I recall, Kissinger noted that U.S. relations with Beijing and Moscow should be better than relations between Beijing and Moscow. This logic of setting countries against each other, practiced by the United States and other Western states, is well known and still in use today. It is neither our approach nor that of China.
0:59

If any agreements reached or to be reached between Beijing and Washington serve the interests of our Chinese friends, we welcome them. However, we will not take part in games based on a “divide and rule” approach. As I recall, Kissinger noted that U.S. relations with Beijing and Moscow should be better than relations between Beijing and Moscow. This logic of setting countries against each other, practiced by the United States and other Western states, is well known and still in use today. It is neither our approach nor that of China.

Military Summary

13,277 Aufrufe • vor 2 Monaten

“Originally conceived as a social experiment, the idea grew out of a wish to stimulate dialogue between two parts of the on-chain, generative art communities. Each particle cloud operates as an autonomous system governed by physics-based algorithms until paired with another instance where behavioural synchronisation emerges” entangled by 𝕭𝖏ø𝖗𝖓 𝕾𝖙𝖆𝖆𝖑 is so good, its a release I’d love to see in a physical setting one day (like in the next post). it was released with fxhash
0:45

“Originally conceived as a social experiment, the idea grew out of a wish to stimulate dialogue between two parts of the on-chain, generative art communities. Each particle cloud operates as an autonomous system governed by physics-based algorithms until paired with another instance where behavioural synchronisation emerges” entangled by 𝕭𝖏ø𝖗𝖓 𝕾𝖙𝖆𝖆𝖑 is so good, its a release I’d love to see in a physical setting one day (like in the next post). it was released with fxhash

Chet Woodside

49,132 Aufrufe • vor 5 Monaten

BeastLink is a giant multiplayer Kaiju experience where humans, vehicles, and colossal Beasts collide 🔸Become dormant Kaiju, unlocking unique abilities, playstyles, and powers 🔸Control a growing roster of Kaiju each with distinct strengths, abilities, and playstyles 🔸Fight as a human or support your squad with vehicles 🔸Level entire cities with a fully-networked, physics-based destruction system 🔸Battle across huge maps designed for up to 32 players and multiple active Kaiju
0:34

BeastLink is a giant multiplayer Kaiju experience where humans, vehicles, and colossal Beasts collide 🔸Become dormant Kaiju, unlocking unique abilities, playstyles, and powers 🔸Control a growing roster of Kaiju each with distinct strengths, abilities, and playstyles 🔸Fight as a human or support your squad with vehicles 🔸Level entire cities with a fully-networked, physics-based destruction system 🔸Battle across huge maps designed for up to 32 players and multiple active Kaiju

Game Hunter

41,502 Aufrufe • vor 2 Monaten

A transformer can learn not just the outcomes of dynamics, but the operator that executes the rules. To show this we trained a transformer on roughly 0.04% of a discrete rule space - 100 of 262,144 possible rules - and it learned to apply unseen rules from the same rule class. The model does not simply memorize specific rules. It learns the operator that maps a supplied rule plus an initial state, including unseen rules from this class, to the correct next state. This is relevant because it is a shift from “neural networks approximate dynamics” to “neural networks can learn to execute symbolic programs within a defined rule class”. The rule itself is supplied at inference time, as data, and the network has internalized how rules act, not which rules to apply. On previously unseen rules, the model achieves 98.5% perfect one-step forecasts and reconstructs governing rules with up to 96% functional accuracy. Two results make this hold up under scrutiny. First, inductive bias decay. As we scaled training rule diversity, the correlation between functional inference accuracy and distance-from-nearest-training-rule collapsed to R² = 0.00. At the largest tested training-rule diversity, the model’s performance on a new rule shows no measurable dependence on how similar that rule is to anything it was trained on. The bias toward training data (the thing we worry most about in compositional generalization claims) is something we can measure decaying, and we find that at scale it is gone. Second, an identifiability theory. We derive a closed-form expression for the number of rules consistent with a single observation. This reframes the inverse problem: failure to recover ground truth is not necessarily a model defect, but can be correct behavior when the data underdetermine the rule. The model is sampling the equivalence class; and identifiability is governed by coverage, not capacity. The methodological move underneath both results is amortization. Classical work on rule inference (e.g. the Santa Fe EVCA program, evolutionary search over CA rule space) was per-instance: search the rule space for each new system. We replace that with a single forward pass of a transformer trained across many instantiations of the rule class. That is what makes symbolic rule inference scalable as a research direction rather than a curiosity. We show that this works in a tightly constrained domain: binary, deterministic, local cellular automata on small grids. The locality-break experiment shows the model fails sharply when target systems violate its structural priors (which is itself a useful diagnostic, but it bounds the operator class). We don't yet know how this scales to multistate, higher-dimensional, or stochastic CA, or whether it transfers cleanly to non-CA systems whose coarse-grained dynamics admit local surrogates. The identifiability framework - what can be inferred from observation, given a hypothesis class - should transfer wherever finite local rules meet sparse data. The amortization argument transfers wherever per-instance symbolic search has been the bottleneck. Those are the pieces I expect to outlive the cellular automata setting. Led by Jaime Berkovich with Noah David, at LAMM@MIT. Out now in Advanced Science Advanced Portfolio (link to paper & code below).
0:49

A transformer can learn not just the outcomes of dynamics, but the operator that executes the rules. To show this we trained a transformer on roughly 0.04% of a discrete rule space - 100 of 262,144 possible rules - and it learned to apply unseen rules from the same rule class. The model does not simply memorize specific rules. It learns the operator that maps a supplied rule plus an initial state, including unseen rules from this class, to the correct next state. This is relevant because it is a shift from “neural networks approximate dynamics” to “neural networks can learn to execute symbolic programs within a defined rule class”. The rule itself is supplied at inference time, as data, and the network has internalized how rules act, not which rules to apply. On previously unseen rules, the model achieves 98.5% perfect one-step forecasts and reconstructs governing rules with up to 96% functional accuracy. Two results make this hold up under scrutiny. First, inductive bias decay. As we scaled training rule diversity, the correlation between functional inference accuracy and distance-from-nearest-training-rule collapsed to R² = 0.00. At the largest tested training-rule diversity, the model’s performance on a new rule shows no measurable dependence on how similar that rule is to anything it was trained on. The bias toward training data (the thing we worry most about in compositional generalization claims) is something we can measure decaying, and we find that at scale it is gone. Second, an identifiability theory. We derive a closed-form expression for the number of rules consistent with a single observation. This reframes the inverse problem: failure to recover ground truth is not necessarily a model defect, but can be correct behavior when the data underdetermine the rule. The model is sampling the equivalence class; and identifiability is governed by coverage, not capacity. The methodological move underneath both results is amortization. Classical work on rule inference (e.g. the Santa Fe EVCA program, evolutionary search over CA rule space) was per-instance: search the rule space for each new system. We replace that with a single forward pass of a transformer trained across many instantiations of the rule class. That is what makes symbolic rule inference scalable as a research direction rather than a curiosity. We show that this works in a tightly constrained domain: binary, deterministic, local cellular automata on small grids. The locality-break experiment shows the model fails sharply when target systems violate its structural priors (which is itself a useful diagnostic, but it bounds the operator class). We don't yet know how this scales to multistate, higher-dimensional, or stochastic CA, or whether it transfers cleanly to non-CA systems whose coarse-grained dynamics admit local surrogates. The identifiability framework - what can be inferred from observation, given a hypothesis class - should transfer wherever finite local rules meet sparse data. The amortization argument transfers wherever per-instance symbolic search has been the bottleneck. Those are the pieces I expect to outlive the cellular automata setting. Led by Jaime Berkovich with Noah David, at LAMM@MIT. Out now in Advanced Science Advanced Portfolio (link to paper & code below).

Markus J. Buehler

39,019 Aufrufe • vor 2 Monaten

New short course: Evaluating AI Agents! Evals are important for driving AI system improvements, and in this course you'll learn to systematically assess and improve an AI agent’s performance. This is built in partnership with Arize AI and taught by John Gilhuly, Head of Developer Relations, and , Director of Product. I've often found evals to be a critical tool in the agent development process - they can be the difference between picking the right thing to work on vs. wasting weeks of effort. Whether you’re building a shopping assistant, coding agent, or research assistant, having a structured evaluation process helps you refine its performance systematically, rather than relying on random trial and error. This course shows you how to structure your evals to assess the performance of each component of an agent and its end-to-end performance. For each component, you select the appropriate evaluators, test examples, and performance metrics. This helps you identify areas for improvement both during development and in production. (If you're familiar with error analysis in supervised learning, think of this as adapting those ideas to agentic workflows.) In this course, you'll build an AI agent, and add observability to visualize and debug its steps. You’ll learn about code-based evals, in which you write code explicitly to test a certain step, as well as LLM-as-a-Judge evals, in which you prompt an LLM to efficiently come up with ways to evaluate more open-ended outputs. In detail, you’ll: - Understand key differences between evaluating LLM-based systems and traditional software testing. - Add observability to an agent by collecting traces of the steps taken by the agent and visualizing them - Choose the appropriate evaluator - code-based, LLM-as-a-Judge, human-annotation based - for each component. - Compute a convergence score to evaluate if your agent can respond to a query in an efficient number of steps. - Run structured experiments to improve the agent’s performance by exploring changes to the prompt, LLM model, or the agent’s logic. - Understand how to deploy these evaluation techniques to monitor the agent’s performance in production. By the end of this course, you’ll know how to trace AI agents, systematically evaluate them, and improve their performance. Please sign up here:
2:07

New short course: Evaluating AI Agents! Evals are important for driving AI system improvements, and in this course you'll learn to systematically assess and improve an AI agent’s performance. This is built in partnership with Arize AI and taught by John Gilhuly, Head of Developer Relations, and , Director of Product. I've often found evals to be a critical tool in the agent development process - they can be the difference between picking the right thing to work on vs. wasting weeks of effort. Whether you’re building a shopping assistant, coding agent, or research assistant, having a structured evaluation process helps you refine its performance systematically, rather than relying on random trial and error. This course shows you how to structure your evals to assess the performance of each component of an agent and its end-to-end performance. For each component, you select the appropriate evaluators, test examples, and performance metrics. This helps you identify areas for improvement both during development and in production. (If you're familiar with error analysis in supervised learning, think of this as adapting those ideas to agentic workflows.) In this course, you'll build an AI agent, and add observability to visualize and debug its steps. You’ll learn about code-based evals, in which you write code explicitly to test a certain step, as well as LLM-as-a-Judge evals, in which you prompt an LLM to efficiently come up with ways to evaluate more open-ended outputs. In detail, you’ll: - Understand key differences between evaluating LLM-based systems and traditional software testing. - Add observability to an agent by collecting traces of the steps taken by the agent and visualizing them - Choose the appropriate evaluator - code-based, LLM-as-a-Judge, human-annotation based - for each component. - Compute a convergence score to evaluate if your agent can respond to a query in an efficient number of steps. - Run structured experiments to improve the agent’s performance by exploring changes to the prompt, LLM model, or the agent’s logic. - Understand how to deploy these evaluation techniques to monitor the agent’s performance in production. By the end of this course, you’ll know how to trace AI agents, systematically evaluate them, and improve their performance. Please sign up here:

Andrew Ng

126,406 Aufrufe • vor 1 Jahr

Excited to share that our paper 🌊🤺 “CFC: Simulating Character–Fluid Coupling using a Two-Level World Model” has been accepted to #SIGGRAPHASIA2025! In this work, we build a two-level world model (neural physics) for rigid-body–fluid interaction and use it to train physics-based character controllers efficiently. We study: (1) learning to model highly dynamic fluid environments, (2) representing character–fluid interaction via joint-level forces as an interface, and (3) enabling supervised policy learning on the learned world model—avoiding expensive fluid simulation in the training loop. Our talk is on Monday afternoon(Dec 15)—hope to see you there! Time: Monday, 15 December 2025 5:02pm - 5:13pm GMT+8 Location: Meeting Room S221, Level 2. #SIGGRAPHASIA #SIGGRAPH
2:18

Excited to share that our paper 🌊🤺 “CFC: Simulating Character–Fluid Coupling using a Two-Level World Model” has been accepted to #SIGGRAPHASIA2025! In this work, we build a two-level world model (neural physics) for rigid-body–fluid interaction and use it to train physics-based character controllers efficiently. We study: (1) learning to model highly dynamic fluid environments, (2) representing character–fluid interaction via joint-level forces as an interface, and (3) enabling supervised policy learning on the learned world model—avoiding expensive fluid simulation in the training loop. Our talk is on Monday afternoon(Dec 15)—hope to see you there! Time: Monday, 15 December 2025 5:02pm - 5:13pm GMT+8 Location: Meeting Room S221, Level 2. #SIGGRAPHASIA #SIGGRAPH

Zhiyang (Frank) Dou

20,200 Aufrufe • vor 7 Monaten

Introducing Continuous Thought Machines New Blog: Modern AI is powerful, but it’s still distinct from human-like flexible intelligence. We believe neural timing is key. Our Continuous Thought Machine is built from the ground up to use neural dynamics as a powerful representation for intelligence. Thought takes time, and reasoning is a process. Biological brains inspire us with their complex neural activity, where neural timing is critical to intelligence. We’re exploring how to bring that power to AI. The Continuous Thought Machine (CTM) incorporates neuron-level temporal processing and neural synchronization, moving beyond current AI limitations. Our approach has two core innovations: (1) neuron-level temporal processing, where each neuron uses unique parameters to process a history of incoming signals for fine-grained temporal dynamics, and (2) neural synchronization, used as a direct latent representation to modulate data and produce outputs, encoding information directly in the timing of neural activity. Learn more about our approach: Interactive Report: Full Paper: GitHub :
0:57

Introducing Continuous Thought Machines New Blog: Modern AI is powerful, but it’s still distinct from human-like flexible intelligence. We believe neural timing is key. Our Continuous Thought Machine is built from the ground up to use neural dynamics as a powerful representation for intelligence. Thought takes time, and reasoning is a process. Biological brains inspire us with their complex neural activity, where neural timing is critical to intelligence. We’re exploring how to bring that power to AI. The Continuous Thought Machine (CTM) incorporates neuron-level temporal processing and neural synchronization, moving beyond current AI limitations. Our approach has two core innovations: (1) neuron-level temporal processing, where each neuron uses unique parameters to process a history of incoming signals for fine-grained temporal dynamics, and (2) neural synchronization, used as a direct latent representation to modulate data and produce outputs, encoding information directly in the timing of neural activity. Learn more about our approach: Interactive Report: Full Paper: GitHub :

Sakana AI

289,680 Aufrufe • vor 1 Jahr

[wip] growing organisms using hypergraph rewriting I'm exploring generating organisms using string forces and I was wondering about which class of algorithms could be used to generalize the growth of such structures. I wanted a system which can produce a wide variety of outputs, while allowing for stable and controlled growth. That's when I thought about Stephen Wolfram (yes again) Physics Project, which proposes to explore a solution to the fundamental theory of physics using a hypergraph rewriting system ( TLDR; Growth of graphs using simple permutation rules. It's similar to cellular automata but for graphs. Could be what I'm looking for. I started to experiment with this system to grow my organisms, and it's definitely a promising approach! Below is a video of the following rules applied to an initial {{0,0},{0,0}} graph: rand() {{x,y},{x,w},{y,w},{z,w}} : {{x,y},{x,z}}->{{x,w},{y,w},{z,w}} There's a lot of areas to improve this exploration, notably: - localization of rules (instead of applying a same rule to the whole system, let each node have its own rules) - spawn control rules (when a new node is created, a rule can define which rules will be applied to such node) - mutation rules (rules which alter rules of adjacent nodes) - conditional rules (many rules can be attached to a node, the one being executed subject to localized conditions) Super exciting, will certainly be the basis of my next project.
1:01

[wip] growing organisms using hypergraph rewriting I'm exploring generating organisms using string forces and I was wondering about which class of algorithms could be used to generalize the growth of such structures. I wanted a system which can produce a wide variety of outputs, while allowing for stable and controlled growth. That's when I thought about Stephen Wolfram (yes again) Physics Project, which proposes to explore a solution to the fundamental theory of physics using a hypergraph rewriting system ( TLDR; Growth of graphs using simple permutation rules. It's similar to cellular automata but for graphs. Could be what I'm looking for. I started to experiment with this system to grow my organisms, and it's definitely a promising approach! Below is a video of the following rules applied to an initial {{0,0},{0,0}} graph: rand() {{x,y},{x,w},{y,w},{z,w}} : {{x,y},{x,z}}->{{x,w},{y,w},{z,w}} There's a lot of areas to improve this exploration, notably: - localization of rules (instead of applying a same rule to the whole system, let each node have its own rules) - spawn control rules (when a new node is created, a rule can define which rules will be applied to such node) - mutation rules (rules which alter rules of adjacent nodes) - conditional rules (many rules can be attached to a node, the one being executed subject to localized conditions) Super exciting, will certainly be the basis of my next project.

ciphrd

77,402 Aufrufe • vor 1 Jahr

Can GPT-4 teach a robot hand to do pen spinning tricks better than you do? I'm excited to announce Eureka, an open-ended agent that designs reward functions for robot dexterity at super-human level. It’s like Voyager in the space of a physics simulator API! Eureka bridges the gap between high-level reasoning (coding) and low-level motor control. It is a “hybrid-gradient architecture”: a black box, inference-only LLM instructs a white box, learnable neural network. The outer loop runs GPT-4 to refine the reward function (gradient-free), while the inner loop runs reinforcement learning to train a robot controller (gradient-based). We are able to scale up Eureka thanks to IsaacGym, a GPU-accelerated physics simulator that speeds up reality by 1000x. On a benchmark suite of 29 tasks across 10 robots, Eureka rewards outperform expert human-written ones on 83% of the tasks by 52% improvement margin on average. We are surprised that Eureka is able to learn pen spinning tricks, which are very difficult even for CGI artists to animate frame by frame! Eureka also enables a new form of in-context RLHF, which is able to incorporate a human operator’s feedback in natural language to steer and align the reward functions. It can serve as a powerful co-pilot for robot engineers to design sophisticated motor behaviors. As usual, we open-source everything! Welcome you all to check out our video gallery and try the codebase today: Paper: Code: Deep dive with me: 🧵
0:24

Can GPT-4 teach a robot hand to do pen spinning tricks better than you do? I'm excited to announce Eureka, an open-ended agent that designs reward functions for robot dexterity at super-human level. It’s like Voyager in the space of a physics simulator API! Eureka bridges the gap between high-level reasoning (coding) and low-level motor control. It is a “hybrid-gradient architecture”: a black box, inference-only LLM instructs a white box, learnable neural network. The outer loop runs GPT-4 to refine the reward function (gradient-free), while the inner loop runs reinforcement learning to train a robot controller (gradient-based). We are able to scale up Eureka thanks to IsaacGym, a GPU-accelerated physics simulator that speeds up reality by 1000x. On a benchmark suite of 29 tasks across 10 robots, Eureka rewards outperform expert human-written ones on 83% of the tasks by 52% improvement margin on average. We are surprised that Eureka is able to learn pen spinning tricks, which are very difficult even for CGI artists to animate frame by frame! Eureka also enables a new form of in-context RLHF, which is able to incorporate a human operator’s feedback in natural language to steer and align the reward functions. It can serve as a powerful co-pilot for robot engineers to design sophisticated motor behaviors. As usual, we open-source everything! Welcome you all to check out our video gallery and try the codebase today: Paper: Code: Deep dive with me: 🧵

Jim Fan

2,674,056 Aufrufe • vor 2 Jahren

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.
0:23

Why the character movement in my custom game engine felt janky and how I fixed it. In a game engine, most often, a character moves using the physics engine. Meaning, the player is not just a coordinate in space but a physical body. It has velocity, it handles collisions, and it interacts with the world. Now, as you might know, physics engines need stability. If you run them at variable framerates, things start breaking. Objects phase through walls or fly off into space because the math becomes unpredictable. This is why most game engines lock their physics loop to a 60Hz fixed rate. But here’s the problem: If you have a high-end system, you don't want to limit it at 60 FPS. That's a waste of good hardware. Now, that said, if the GPU is rendering at 144 FPS but the player's position (physics driven) only updates 60 times a second, it creates a micro-stutter that ruins the "smooth" feel of the game. A good way to fix this is to treat the character as two separate things: 1. The Physics Body (Invisible part): This is the "real" character. It lives in the 60Hz physics world, it moves the player and handles collisions. 2. The Visual Model and Camera (Visible part): This is what the player actually sees. It doesn't care about collisions, its only job is to look nice and smooth at whatever framerate the GPU is pushing. Once you have this separation, you can use interpolation to keep them in sync. Every time the physics clock ticks, you save the previous position of the invisible body before moving it to the new one. Between those ticks, calculate how far we are between the last physics update and the next one. By using this to drive the visible parts of the game, the stutters disappear. The physics loop stays fixed behind the scenes, while the visuals slide smoothly between the snapshots. Example: - Right after a tick: blend_weight= 0.0 (The visual model stays at the old physics position). - Halfway to the next: blend_weight= 0.5 (The visual model slides to the middle point). - Just before the next: blend_weight= 0.9 (The visual model is almost at the new physics position). Pro-Tip A critical mistake I made initially, and one many devs make, is parenting the camera and visible parts directly to the player body. If you do this, the camera inherits the discrete 60Hz physics movement by default. In that setup, interpolation won't work because the camera is "stuck" to the physics clock. For this fix to work you must decouple the camera and visuals from the body and move them separately. Player movement processing in Detis Engine: - fixed_process: Physics runs at 60Hz. Handles collisions and raw movement. - process: Variable rate. Mainly used for player input caching in the player case. - late_process: Variable rate. Handles interpolated camera movement after physics and everything else is done being processed. - render. Submits the final interpolated transforms to the GPU. The test environment in the video is running on an old 2070-based laptop. Hopefully the video compression won't introduce any stutter... I’m sharing this in hopes it helps a fellow dev. Cheers.

Ioannis Koukourakis

48,518 Aufrufe • vor 6 Monaten

What started as building a personal taste.md skill for myself, turned into building a pipeline to create any taste as a skill. The most important piece is references. This is where you should spend time. If the references suck, so does the skill. I find that references cropped tightly on details in high resolution work the best. Each image gets analyzed by both Opus 4.7 and GPT 5.5. The analysis is based on why the reference is successful as a piece of design - not what it does functionally. Using two models helps rule out biases and gaps from each. The models focus on layout, spacing, typography, rhythm, composition, hierarchy, etc. At the end, each image has: reference-01/ - opus-4-7-analysis.md - gpt-5-5-analysis.md Then we fuse them together using GPT 5.5 - but the md files are anonymized so 5.5 doesn't prefer itself. reference-01/ - fused-analysis.md reference-02/ - fused-analysis.md etc. After fusion, we have one synthesized analysis per reference. Now the goal is to combine all of those into a single rule set. This is where chunking matters. If you ask one model to combine 100 image analyses at once, the result becomes too broad. It summarizes instead of preserving the granular design rules we want. Instead we chunk the fused analyses into smaller groups. Each group gets merged into a chunk-level synthesis, usually from around 6 to 8 image notes at a time. Then one final model pass fuses those chunks into a single md rule set. Finally, using the rule set, we write a skill of concrete instructions. It enforces constraints, uses imperative wording, and avoids vague taste words.
3:43

What started as building a personal taste.md skill for myself, turned into building a pipeline to create any taste as a skill. The most important piece is references. This is where you should spend time. If the references suck, so does the skill. I find that references cropped tightly on details in high resolution work the best. Each image gets analyzed by both Opus 4.7 and GPT 5.5. The analysis is based on why the reference is successful as a piece of design - not what it does functionally. Using two models helps rule out biases and gaps from each. The models focus on layout, spacing, typography, rhythm, composition, hierarchy, etc. At the end, each image has: reference-01/ - opus-4-7-analysis.md - gpt-5-5-analysis.md Then we fuse them together using GPT 5.5 - but the md files are anonymized so 5.5 doesn't prefer itself. reference-01/ - fused-analysis.md reference-02/ - fused-analysis.md etc. After fusion, we have one synthesized analysis per reference. Now the goal is to combine all of those into a single rule set. This is where chunking matters. If you ask one model to combine 100 image analyses at once, the result becomes too broad. It summarizes instead of preserving the granular design rules we want. Instead we chunk the fused analyses into smaller groups. Each group gets merged into a chunk-level synthesis, usually from around 6 to 8 image notes at a time. Then one final model pass fuses those chunks into a single md rule set. Finally, using the rule set, we write a skill of concrete instructions. It enforces constraints, uses imperative wording, and avoids vague taste words.

Jaytel

55,377 Aufrufe • vor 1 Monat

Chamath Palihapitiya said Kimi K2.5 is going to save 90% of the cost, mentioning it as a winning moment for open-source models. Some notes from the latest All-In Podcast: > Natively supports video-to-code > 256K massive context windows > Open-sourced their "Agent Swarm" feature > Allows 100+ sub-agents to solve complex tasks by running 1,500 steps in parallel > Available to everyone, frontier-level reasoning (#1 on LLM Leaderboard, via OpenRouter) It is a major shift where open source is now challenging the dominance of closed-source models.
2:02

Chamath Palihapitiya said Kimi K2.5 is going to save 90% of the cost, mentioning it as a winning moment for open-source models. Some notes from the latest All-In Podcast: > Natively supports video-to-code > 256K massive context windows > Open-sourced their "Agent Swarm" feature > Allows 100+ sub-agents to solve complex tasks by running 1,500 steps in parallel > Available to everyone, frontier-level reasoning (#1 on LLM Leaderboard, via OpenRouter) It is a major shift where open source is now challenging the dominance of closed-source models.

Poonam Soni

56,165 Aufrufe • vor 5 Monaten

Introducing PAN — MBZUAI’s New World Model for Interactive Intelligence Developed by MBZUAI’s Institute of Foundation Models, PAN is built for simulation, prediction, and agentic reasoning. Unlike traditional video generators that only output frames, PAN maintains a persistent internal state that evolves when guided with natural language. Its Generative Latent Prediction architecture combines: • A latent encoder to capture the world state • A dynamics module that evolves that state step-by-step • A video diffusion decoder that visualizes outcomes By decoding at every step using a causal sliding-window diffusion process, PAN stays grounded in real-world physics and maintains long-horizon continuity, a leap beyond single-shot models. Evaluated on action fidelity, long-horizon stability, and simulative planning, PAN delivers state-of-the-art performance compared to open models and rivals leading commercial systems. For robotics, autonomy, and decision support, PAN is a foundation for the next wave of intelligent, foresight-driven AI.
1:06

Introducing PAN — MBZUAI’s New World Model for Interactive Intelligence Developed by MBZUAI’s Institute of Foundation Models, PAN is built for simulation, prediction, and agentic reasoning. Unlike traditional video generators that only output frames, PAN maintains a persistent internal state that evolves when guided with natural language. Its Generative Latent Prediction architecture combines: • A latent encoder to capture the world state • A dynamics module that evolves that state step-by-step • A video diffusion decoder that visualizes outcomes By decoding at every step using a causal sliding-window diffusion process, PAN stays grounded in real-world physics and maintains long-horizon continuity, a leap beyond single-shot models. Evaluated on action fidelity, long-horizon stability, and simulative planning, PAN delivers state-of-the-art performance compared to open models and rivals leading commercial systems. For robotics, autonomy, and decision support, PAN is a foundation for the next wave of intelligent, foresight-driven AI.

MBZUAI

98,725 Aufrufe • vor 8 Monaten

Introducing Teleport 2.0, a next-generation release for our 3D capture solution that sets a new benchmark in cloud-based Gaussian Splatting. Teleport 2.0 is all about lowering the barrier of entry to create and share lifelike 3D captures. New capabilities include: ▪️ Upgraded 3D reconstruction engine: Preserves real-world detail, even in large-scale scenes that can be captured in minutes and automatically processed without manual steps. ▪️Support for any camera: Capture with phones, drones, professional cameras, or other imaging devices. ▪️ Tools for creating engaging immersive experiences: Build virtual tours, or link multiple scans together to build massive explorable digital twins. Read more: #3D #DigitalTwin #GaussianSplatting
0:40

Introducing Teleport 2.0, a next-generation release for our 3D capture solution that sets a new benchmark in cloud-based Gaussian Splatting. Teleport 2.0 is all about lowering the barrier of entry to create and share lifelike 3D captures. New capabilities include: ▪️ Upgraded 3D reconstruction engine: Preserves real-world detail, even in large-scale scenes that can be captured in minutes and automatically processed without manual steps. ▪️Support for any camera: Capture with phones, drones, professional cameras, or other imaging devices. ▪️ Tools for creating engaging immersive experiences: Build virtual tours, or link multiple scans together to build massive explorable digital twins. Read more: #3D #DigitalTwin #GaussianSplatting

Varjo

21,211 Aufrufe • vor 1 Jahr

Synchronize Dual Hands for Physics-Based Dexterous Guitar Playing discuss: We present a novel approach to synthesize dexterous motions for physically simulated hands in tasks that require coordination between the control of two hands with high temporal precision. Instead of directly learning a joint policy to control two hands, our approach performs bimanual control through cooperative learning where each hand is treated as an individual agent. The individual policies for each hand are first trained separately, and then synchronized through latent space manipulation in a centralized environment to serve as a joint policy for two-hand control. By doing so, we avoid directly performing policy learning in the joint state-action space of two hands with higher dimensions, greatly improving the overall training efficiency. We demonstrate the effectiveness of our proposed approach in the challenging guitar-playing task. The virtual guitarist trained by our approach can synthesize motions from unstructured reference data of general guitar-playing practice motions, and accurately play diverse rhythms with complex chord pressing and string picking patterns based on the input guitar tabs that do not exist in the references. Along with this paper, we provide the motion capture data that we collected as the reference for policy training.
6:21

Synchronize Dual Hands for Physics-Based Dexterous Guitar Playing discuss: We present a novel approach to synthesize dexterous motions for physically simulated hands in tasks that require coordination between the control of two hands with high temporal precision. Instead of directly learning a joint policy to control two hands, our approach performs bimanual control through cooperative learning where each hand is treated as an individual agent. The individual policies for each hand are first trained separately, and then synchronized through latent space manipulation in a centralized environment to serve as a joint policy for two-hand control. By doing so, we avoid directly performing policy learning in the joint state-action space of two hands with higher dimensions, greatly improving the overall training efficiency. We demonstrate the effectiveness of our proposed approach in the challenging guitar-playing task. The virtual guitarist trained by our approach can synthesize motions from unstructured reference data of general guitar-playing practice motions, and accurately play diverse rhythms with complex chord pressing and string picking patterns based on the input guitar tabs that do not exist in the references. Along with this paper, we provide the motion capture data that we collected as the reference for policy training.

AK

26,855 Aufrufe • vor 1 Jahr

A White Hole is a Black Hole Running Backward A Black Hole is famous because it lets things fall in, but never lets them come back out. A White Hole is the time-reversed version of that idea. In the full Schwarzschild solution of General Relativity, the Black-Hole region and the White-Hole region appear as two different causal parts of the same exact geometry. Outside the horizon, the metric is the usual Schwarzschild metric ds² = -(1 - 2M/r)dt² + (1 - 2M/r)⁻¹dr² + r²dΩ². The horizon sits at rₛ = 2M, using G = c = 1. For an ordinary Black Hope, future-directed paths can cross this surface inward. Once they do, they cannot return to the outside universe. For a White Hole, the arrow is reversed and particles and light can come out from the horizon, but outside observers cannot enter it. No one has observed a physical White Hole. It may be an ideal solution rather than an object that nature actually forms. But as Mathematics, it is one of the strangest lessons of General Relativity: The equations allow a horizon that throws the universe outward. #WhiteHoles #GeneralRelativity #Schwarzschild #Spacetime #BlackHoles #Cosmology #Physics #Mathematics #Astrophysics #Astronomy
0:56

A White Hole is a Black Hole Running Backward A Black Hole is famous because it lets things fall in, but never lets them come back out. A White Hole is the time-reversed version of that idea. In the full Schwarzschild solution of General Relativity, the Black-Hole region and the White-Hole region appear as two different causal parts of the same exact geometry. Outside the horizon, the metric is the usual Schwarzschild metric ds² = -(1 - 2M/r)dt² + (1 - 2M/r)⁻¹dr² + r²dΩ². The horizon sits at rₛ = 2M, using G = c = 1. For an ordinary Black Hope, future-directed paths can cross this surface inward. Once they do, they cannot return to the outside universe. For a White Hole, the arrow is reversed and particles and light can come out from the horizon, but outside observers cannot enter it. No one has observed a physical White Hole. It may be an ideal solution rather than an object that nature actually forms. But as Mathematics, it is one of the strangest lessons of General Relativity: The equations allow a horizon that throws the universe outward. #WhiteHoles #GeneralRelativity #Schwarzschild #Spacetime #BlackHoles #Cosmology #Physics #Mathematics #Astrophysics #Astronomy

Mathelirium

44,045 Aufrufe • vor 20 Tagen

Recipe to post-train Qwen3 1.7B into a DeepResearch model What does it mean for something small to think deeply? Meet Lucy, a post‑trained Qwen3‑1.7B as a DeepResearch model based on will brown's verifiers. Primary Rule-based Rewards: - Answer correctness We check whether the final response literally contains the ground-truth answer. This substring match is cheap and avoids calling a larger LLM judge. - Visit/search ratio If the agent visits at least as many pages as it issues search queries, it receives ((visit_search_ratio - 1) / 4) ** 0.25. If it searches more than it visits, the score is -0.5. Format / Anti Reward-Hacking Rewards: - Tool execution success Each API call that returns without an error counts. The reward is (successful_calls * unique_tools_used) / total_call_attempts. - Thinking efficiency A skew-normal penalty centered at 70 tokens discourages endless chain-of-thought between tool calling while still allowing enough tokens for planning. This is how Qwen3 1.7B learned to search, visit, and synthesize information. Small models can do deep research too!
0:46

Recipe to post-train Qwen3 1.7B into a DeepResearch model What does it mean for something small to think deeply? Meet Lucy, a post‑trained Qwen3‑1.7B as a DeepResearch model based on will brown's verifiers. Primary Rule-based Rewards: - Answer correctness We check whether the final response literally contains the ground-truth answer. This substring match is cheap and avoids calling a larger LLM judge. - Visit/search ratio If the agent visits at least as many pages as it issues search queries, it receives ((visit_search_ratio - 1) / 4) ** 0.25. If it searches more than it visits, the score is -0.5. Format / Anti Reward-Hacking Rewards: - Tool execution success Each API call that returns without an error counts. The reward is (successful_calls * unique_tools_used) / total_call_attempts. - Thinking efficiency A skew-normal penalty centered at 70 tokens discourages endless chain-of-thought between tool calling while still allowing enough tokens for planning. This is how Qwen3 1.7B learned to search, visit, and synthesize information. Small models can do deep research too!

Casper Hansen

39,684 Aufrufe • vor 1 Jahr