Загрузка видео...

Не удалось загрузить видео

На главную

📢Diff3r: fast feed-forward 3DGS + per-scene optimization Yueh-Cheng Liu predicts optimization-ready 3DGS init end to end, computing implicit gradients via Implicit Function Theorem + Gauss-Newton approximation for fast & stable results Check it out:

angelaqdai's profile picture

Angela Dai

9,881 subscribers

18,013 просмотров • 5 месяцев назад •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

Комментарии: 1

Фото профиля Wenpu Li (李文朴)
Wenpu Li (李文朴)5 месяцев назад

@liuyuehcheng What differential optimization framework do you use？ ［meta theseus］ or self-implemented？

Похожие видео

Check out 🌟Vid2Sim: Generalizable, Video-based Reconstruction of Appearance, Geometry & Physics for Mesh-Free Simulation #CVPR2025, from Lingjie Liu’s lab at UPenn. Congrats to Chuhao Chen! Vid2Sim aims to achieve system identification by reconstructing geometry, appearance, and physical properties directly from video. It combines learned data priors with closed-loop optimization: a feed-forward predictor trained on physical prior, followed by fast refinement via Neural Jacobian and mesh-free simulation. The system delivers simulation-ready outputs in minutes, with strong generalization across objects and materials. 🏠Project page: #PhysicalAI #AIGC #CV #CG #simulation #graphics
1:06

Check out 🌟Vid2Sim: Generalizable, Video-based Reconstruction of Appearance, Geometry & Physics for Mesh-Free Simulation #CVPR2025, from Lingjie Liu’s lab at UPenn. Congrats to Chuhao Chen! Vid2Sim aims to achieve system identification by reconstructing geometry, appearance, and physical properties directly from video. It combines learned data priors with closed-loop optimization: a feed-forward predictor trained on physical prior, followed by fast refinement via Neural Jacobian and mesh-free simulation. The system delivers simulation-ready outputs in minutes, with strong generalization across objects and materials. 🏠Project page: #PhysicalAI #AIGC #CV #CG #simulation #graphics

Zhiyang (Frank) Dou

12,441 просмотров • 1 год назад

The Genie 3 release is a perfect moment to have a discussion about the future of 3D But first it would be nice to make the terminology more clear, specifically: What is a “spatial representation” Implicit vs Explicit Generalization vs Specialization Reconstruction vs Generation Production vs Execution Let’s start: For me, a spatial representation is just a way to describe a thing in the physical world The core property that makes it useful is consistency You can enforce consistency explicitly via rendering equations, geometric constraints, and physics Or implicitly, purely through training data Then, your representation parameters can be explicit, like points, gaussians, triangles, voxels, etc. Or implicit, weights or latent vectors Parameters alone are not the representation. It’s a combination of the parameters, the process that produces them, and the way you materialize them through a function (physics-based rendering, simulation, neural network, etc.) Generalization means you take data from multiple scene observations, and then produce a map from desired input to representation parameters Specialization means you take single-scene observations and directly fit a function parameters to describe thar scene Many representations can serve both of the approaches, as long as you keep them differentiable Both of the above can be used for reconstruction, where the main goal is to explain observations through a lens of physics (hard constraint) On the other hand, generation needs generalization, and its task is to produce statistically plausible results that could be conditioned on observations (soft constraint) Both tasks are not solved yet and they can complement each other in various ways Yet another important aspect is the difference between production and execution Production = process of going from inputs to parameters Execution = process of going from parameters to result It’s important to separate these, because most usecases require fast execution to be viable which is severely constrained by the hardware So, are *world models* like Genie an important step forward? Yes Do they make other representations obsolete? Maybe some of them - but there are tons of economically valuable tasks that won’t be solved by it, at least in any observable future
0:33

The Genie 3 release is a perfect moment to have a discussion about the future of 3D But first it would be nice to make the terminology more clear, specifically: What is a “spatial representation” Implicit vs Explicit Generalization vs Specialization Reconstruction vs Generation Production vs Execution Let’s start: For me, a spatial representation is just a way to describe a thing in the physical world The core property that makes it useful is consistency You can enforce consistency explicitly via rendering equations, geometric constraints, and physics Or implicitly, purely through training data Then, your representation parameters can be explicit, like points, gaussians, triangles, voxels, etc. Or implicit, weights or latent vectors Parameters alone are not the representation. It’s a combination of the parameters, the process that produces them, and the way you materialize them through a function (physics-based rendering, simulation, neural network, etc.) Generalization means you take data from multiple scene observations, and then produce a map from desired input to representation parameters Specialization means you take single-scene observations and directly fit a function parameters to describe thar scene Many representations can serve both of the approaches, as long as you keep them differentiable Both of the above can be used for reconstruction, where the main goal is to explain observations through a lens of physics (hard constraint) On the other hand, generation needs generalization, and its task is to produce statistically plausible results that could be conditioned on observations (soft constraint) Both tasks are not solved yet and they can complement each other in various ways Yet another important aspect is the difference between production and execution Production = process of going from inputs to parameters Execution = process of going from parameters to result It’s important to separate these, because most usecases require fast execution to be viable which is severely constrained by the hardware So, are *world models* like Genie an important step forward? Yes Do they make other representations obsolete? Maybe some of them - but there are tons of economically valuable tasks that won’t be solved by it, at least in any observable future

Lucky Iyinbor

13,959 просмотров • 7 месяцев назад

3D scanning and rendering is moving so fast - got my splats up and running and I'm mind blown getting ~100fps for this complex 3D scene ⬇️ 🤯 1. WAY faster than NeRF: For comparison, NeRFs would takes around 10 seconds per frame (!) Instead I'm zipping around with FPV controls without breaking a sweat - though I do crash a few times towards the end of the video lol 2. Old Meets New: Gaussian Splatting is cool in that it fuses classical graphics and deep learning techniques. Like NeRFs, this is still a radiance field - just without the slower (ne)ural rendering part. 3. Explicit Representation: Instead you represent a 3D scene as a collection of ellipsoidal "splats" called gaussians. Each gaussian has a position, size, and color. Rendering in real-time is done by projecting into the image plane and alpha blending. 4. Photorealistic Effects: Gaussian splatting use spherical harmonics to represent the view-dependent effects and lighting - allowing surfaces to change color when viewed from different angles, enabling greater photorealism. It doesn't use a neural network, but the training loop is similar to deep learning. 5. Enables Direct Editing: But it's not just speed - with Gaussian Splatting you also get 3D editing support! So you can select, move, and delete stuff, even relight stuff. This type of editing has been more tedious to do with NeRFs and their implicit black box representations. 📲 More tests cooking! Much more to unpack here including simpler explanations. If you enjoyed this post, you might enjoy my feed: Bilawal Sidhu
0:35

3D scanning and rendering is moving so fast - got my splats up and running and I'm mind blown getting ~100fps for this complex 3D scene ⬇️ 🤯 1. WAY faster than NeRF: For comparison, NeRFs would takes around 10 seconds per frame (!) Instead I'm zipping around with FPV controls without breaking a sweat - though I do crash a few times towards the end of the video lol 2. Old Meets New: Gaussian Splatting is cool in that it fuses classical graphics and deep learning techniques. Like NeRFs, this is still a radiance field - just without the slower (ne)ural rendering part. 3. Explicit Representation: Instead you represent a 3D scene as a collection of ellipsoidal "splats" called gaussians. Each gaussian has a position, size, and color. Rendering in real-time is done by projecting into the image plane and alpha blending. 4. Photorealistic Effects: Gaussian splatting use spherical harmonics to represent the view-dependent effects and lighting - allowing surfaces to change color when viewed from different angles, enabling greater photorealism. It doesn't use a neural network, but the training loop is similar to deep learning. 5. Enables Direct Editing: But it's not just speed - with Gaussian Splatting you also get 3D editing support! So you can select, move, and delete stuff, even relight stuff. This type of editing has been more tedious to do with NeRFs and their implicit black box representations. 📲 More tests cooking! Much more to unpack here including simpler explanations. If you enjoyed this post, you might enjoy my feed: Bilawal Sidhu

Bilawal Sidhu

337,090 просмотров • 3 лет назад

🚀 Announcing Echo — our new frontier model for 3D world generation. Echo turns a simple text prompt or image into a fully explorable, 3D-consistent world. Instead of disconnected views, the result is a single, coherent spatial representation you can move through freely. This is part of a bigger shift in AI: from generating pixels and tokens to generating spaces. Echo predicts a geometry-grounded 3D scene at metric scale, meaning every novel view, depth map, and interaction comes from the same underlying world — not independent hallucinations. Once generated, the world is interactive in real time. You control the camera, explore from any angle, and render instantly — even on low-end hardware, directly in the browser. High-quality 3D world exploration is no longer gated by expensive equipment. Under the hood, Echo infers a physically grounded 3D representation and converts it into a renderable format. For our web demo, we use 3D Gaussian Splatting (3DGS) for fast, GPU-friendly rendering — but the representation itself is flexible and can be easily adapted. Why this matters: consistent 3D worlds unlock real workflows — digital twins, 3D design, game environments, robotics simulation, and more. From a single photo or a line of text, Echo builds worlds that are reliable, editable, and spatially faithful. Echo also enables scene editing and restyling. Change materials, remove or add objects, explore design variations — all while preserving global 3D consistency. Editing no longer breaks the world. This is only the beginning. Echo is the foundation for future world models with dynamics, physical reasoning, and richer interaction — environments that don’t just look right, but behave right. Explore the generated worlds on our website and sign up for the closed beta. The era of spatial intelligence starts here. 🌍 #Echo #WorldModels #SpatialAI #3DFoundationModels Check it out:
1:07

🚀 Announcing Echo — our new frontier model for 3D world generation. Echo turns a simple text prompt or image into a fully explorable, 3D-consistent world. Instead of disconnected views, the result is a single, coherent spatial representation you can move through freely. This is part of a bigger shift in AI: from generating pixels and tokens to generating spaces. Echo predicts a geometry-grounded 3D scene at metric scale, meaning every novel view, depth map, and interaction comes from the same underlying world — not independent hallucinations. Once generated, the world is interactive in real time. You control the camera, explore from any angle, and render instantly — even on low-end hardware, directly in the browser. High-quality 3D world exploration is no longer gated by expensive equipment. Under the hood, Echo infers a physically grounded 3D representation and converts it into a renderable format. For our web demo, we use 3D Gaussian Splatting (3DGS) for fast, GPU-friendly rendering — but the representation itself is flexible and can be easily adapted. Why this matters: consistent 3D worlds unlock real workflows — digital twins, 3D design, game environments, robotics simulation, and more. From a single photo or a line of text, Echo builds worlds that are reliable, editable, and spatially faithful. Echo also enables scene editing and restyling. Change materials, remove or add objects, explore design variations — all while preserving global 3D consistency. Editing no longer breaks the world. This is only the beginning. Echo is the foundation for future world models with dynamics, physical reasoning, and richer interaction — environments that don’t just look right, but behave right. Explore the generated worlds on our website and sign up for the closed beta. The era of spatial intelligence starts here. 🌍 #Echo #WorldModels #SpatialAI #3DFoundationModels Check it out:

SpAItial AI

176,903 просмотров • 9 месяцев назад

Alright, this one’s worth your attention if you’re building or deploying agents. Future AGI just open-sourced their entire platform and i don’t mean a trimmed-down version. this is the full stack: UI, backend, simulation engine, evals, optimization loop, observability, guardrails, gateway, docs. all in one repo. Apache 2.0. I’ve been putting it through its paces on production agents, and what stands out isn’t just the breadth it’s the architecture. Most of the current “agent reliability” stack is fragmented. tracing lives in one tool, evals in another, guardrails somewhere else. you end up manually connecting dots, and the agent itself doesn’t really improve you just keep patching prompts and hoping for the best. This flips that model. It’s built as a closed feedback loop: simulate failures → evaluate in real time → detect production issues → learn from them → generate fixes → validate against real traffic → check regressions → redeploy → monitor again And when something new breaks, the loop just runs again. no manual glue. The simulation piece is especially strong. instead of static test cases, it generates adversarial, multi-turn conversations based on how your agent actually behaves basically hunting for the exact scenarios where your system fails confidently. ran a few thousand simulations on our side… caught things we definitely would’ve missed. Evals run fast (sub-50ms) across modalities. not LLM-as-judge trained classifiers. guardrails are built-in, not layered on top. observability gives you step-level visibility into reasoning, cost, latency, quality. But the real shift is the optimization loop. Most tools tell you *what* broke. this system actually fixes it, validates the fix, and ensures nothing else regresses. That’s the missing layer. It’s clearly built with production in mind not a research demo. and the fact that it’s self-hostable makes it even more relevant if you’re running serious workloads. If you’ve been duct-taping together infra around your agents, this is probably the closest thing to a unified system i’ve seen so far. Worth checking out. If you're serious about deploying reliable AI agents, this is worth a look: 👉 You can also try it instantly (no setup) via their cloud version:
2:20

Alright, this one’s worth your attention if you’re building or deploying agents. Future AGI just open-sourced their entire platform and i don’t mean a trimmed-down version. this is the full stack: UI, backend, simulation engine, evals, optimization loop, observability, guardrails, gateway, docs. all in one repo. Apache 2.0. I’ve been putting it through its paces on production agents, and what stands out isn’t just the breadth it’s the architecture. Most of the current “agent reliability” stack is fragmented. tracing lives in one tool, evals in another, guardrails somewhere else. you end up manually connecting dots, and the agent itself doesn’t really improve you just keep patching prompts and hoping for the best. This flips that model. It’s built as a closed feedback loop: simulate failures → evaluate in real time → detect production issues → learn from them → generate fixes → validate against real traffic → check regressions → redeploy → monitor again And when something new breaks, the loop just runs again. no manual glue. The simulation piece is especially strong. instead of static test cases, it generates adversarial, multi-turn conversations based on how your agent actually behaves basically hunting for the exact scenarios where your system fails confidently. ran a few thousand simulations on our side… caught things we definitely would’ve missed. Evals run fast (sub-50ms) across modalities. not LLM-as-judge trained classifiers. guardrails are built-in, not layered on top. observability gives you step-level visibility into reasoning, cost, latency, quality. But the real shift is the optimization loop. Most tools tell you *what* broke. this system actually fixes it, validates the fix, and ensures nothing else regresses. That’s the missing layer. It’s clearly built with production in mind not a research demo. and the fact that it’s self-hostable makes it even more relevant if you’re running serious workloads. If you’ve been duct-taping together infra around your agents, this is probably the closest thing to a unified system i’ve seen so far. Worth checking out. If you're serious about deploying reliable AI agents, this is worth a look: 👉 You can also try it instantly (no setup) via their cloud version:

Aakash Verma

22,915 просмотров • 4 месяцев назад

🚨 SIGGRAPH Asia 2025 Paper Alert 🚨 ➡️Paper Title: WorldExplorer: Towards Generating Fully Navigable 3D Scenes 🌟Few pointers from the paper 🎯Generating 3D worlds from text is a highly anticipated goal in computer vision. Existing works are limited by the degree of exploration they allow inside of a scene, i.e., produce stretched-out and noisy artifacts when moving beyond central or panoramic perspectives. 🎯 To this end, authors of this paper proposed “WorldExplorer”, a novel method based on autoregressive video trajectory generation, which builds fully navigable 3D scenes with consistent visual quality across a wide range of viewpoints. 🎯They initialize their scenes by creating multi-view consistent images corresponding to a 360 degree panorama. 🎯Then, they expanded it by leveraging video diffusion models in an iterative scene generation pipeline. 🎯Concretely, they generated multiple videos along short, pre-defined trajectories, that explore the scene in depth, including motion around objects. 🎯Their novel scene memory conditions each video on the most relevant prior views, while a collision-detection mechanism prevents degenerate results, like moving into objects. 🎯Finally,they fuse all generated views into a unified 3D representation via 3D Gaussian Splatting optimization. 🎯Compared to prior approaches, WorldExplorer produces high-quality scenes that remain stable under large camera motion, enabling for the first time realistic and unrestricted exploration. 🎯They believe this marks a significant step toward generating immersive and truly explorable virtual 3D environments. 🏢Organization: TU München 🧙Paper Authors: Manuel-Andreas Schneider, Lukas Höllein , Matthias Niessner 📝 Read the Full Paper here: 🗂️ Project Page: 🧑‍💻 Code: 🎥 Be sure to watch the attached Technical Summary Video - Sound on 🔊🔊 Find this Valuable 💎 ? ♻️QT and teach your network something new Follow me 👣, naveen manwani , for the latest updates on Tech and AI-related news, insightful research papers, and exciting announcements. #SIGGRAPHAsia2025
3:36

🚨 SIGGRAPH Asia 2025 Paper Alert 🚨 ➡️Paper Title: WorldExplorer: Towards Generating Fully Navigable 3D Scenes 🌟Few pointers from the paper 🎯Generating 3D worlds from text is a highly anticipated goal in computer vision. Existing works are limited by the degree of exploration they allow inside of a scene, i.e., produce stretched-out and noisy artifacts when moving beyond central or panoramic perspectives. 🎯 To this end, authors of this paper proposed “WorldExplorer”, a novel method based on autoregressive video trajectory generation, which builds fully navigable 3D scenes with consistent visual quality across a wide range of viewpoints. 🎯They initialize their scenes by creating multi-view consistent images corresponding to a 360 degree panorama. 🎯Then, they expanded it by leveraging video diffusion models in an iterative scene generation pipeline. 🎯Concretely, they generated multiple videos along short, pre-defined trajectories, that explore the scene in depth, including motion around objects. 🎯Their novel scene memory conditions each video on the most relevant prior views, while a collision-detection mechanism prevents degenerate results, like moving into objects. 🎯Finally,they fuse all generated views into a unified 3D representation via 3D Gaussian Splatting optimization. 🎯Compared to prior approaches, WorldExplorer produces high-quality scenes that remain stable under large camera motion, enabling for the first time realistic and unrestricted exploration. 🎯They believe this marks a significant step toward generating immersive and truly explorable virtual 3D environments. 🏢Organization: TU München 🧙Paper Authors: Manuel-Andreas Schneider, Lukas Höllein , Matthias Niessner 📝 Read the Full Paper here: 🗂️ Project Page: 🧑‍💻 Code: 🎥 Be sure to watch the attached Technical Summary Video - Sound on 🔊🔊 Find this Valuable 💎 ? ♻️QT and teach your network something new Follow me 👣, naveen manwani , for the latest updates on Tech and AI-related news, insightful research papers, and exciting announcements. #SIGGRAPHAsia2025

naveen manwani

10,578 просмотров • 11 месяцев назад

Jensen Huang just reframed the entire history of computing in two minutes. The argument is deceptively simple, but once you see it you can't unsee it. Every single piece of software ever built, every app, every website, every search engine, every platform operated on exactly the same fundamental principle. Someone creates content, it gets stored somewhere and when you ask for it, the system retrieves it. Google indexes the web and retrieves the right page, YouTube encodes your video and retrieves it when someone clicks, Amazon photographs every product in its catalog and retrieves the listing that matches your search. Every recommender system, every ad platform, every social feed, all of it, without exception, is a retrieval operation dressed up in a user interface and we called it the Information Age. But strip away the branding and what you had, for 30 consecutive years, was an extraordinarily sophisticated filing cabinet. The smartest engineers in the world spent their careers optimizing how fast you could put things in and pull things out. Generative AI doesn't just improve that system but rather replaces the entire premise of it. Instead of retrieving content that was pre-recorded by someone else, AI generates it from scratch, in real time, calibrated to your exact context, your specific intent, the precise ground truth of that moment. The same question asked twice gets two different answers, both tailored to what the system knows about you right now. There is no file being pulled or a pre-recorded version, the content is being synthesized on the fly from a compressed model of human knowledge, shaped to fit exactly what you need. The implications of this for the companies that built the retrieval era are profound and already starting to show. Google's click-through rates on organic search results have dropped 61% since AI Overviews rolled out, because users are getting answers directly instead of clicking through to files. Gartner projects traditional search engine query volume drops 25% by the end of 2026 as users migrate to generative interfaces. And yet this is exactly what Jensen predicted, in the old world, the computing bottleneck was storage and retrieval, you needed hard drives, bandwidth, and CDNs. In the new world, the bottleneck is computation, you need the raw processing power to generate tokens at scale, millions of times per second, for millions of simultaneous users. Inference computing demand has grown roughly ten thousand times in the last two years alone. That shift is precisely why Nvidia's revenue opportunity forecast just jumped from $500 billion through 2026 to $1 trillion through 2027. The retrieval era needed CPUs and storage and the generative era needs GPUs, token factories, and inference infrastructure at a scale never built before and Nvidia builds the engine underneath all of it. Jensen has been making this argument since 2024. Most people wrote it off as a chip salesman talking his book but two years later, it's the architecture of the entire industry.
1:54

Jensen Huang just reframed the entire history of computing in two minutes. The argument is deceptively simple, but once you see it you can't unsee it. Every single piece of software ever built, every app, every website, every search engine, every platform operated on exactly the same fundamental principle. Someone creates content, it gets stored somewhere and when you ask for it, the system retrieves it. Google indexes the web and retrieves the right page, YouTube encodes your video and retrieves it when someone clicks, Amazon photographs every product in its catalog and retrieves the listing that matches your search. Every recommender system, every ad platform, every social feed, all of it, without exception, is a retrieval operation dressed up in a user interface and we called it the Information Age. But strip away the branding and what you had, for 30 consecutive years, was an extraordinarily sophisticated filing cabinet. The smartest engineers in the world spent their careers optimizing how fast you could put things in and pull things out. Generative AI doesn't just improve that system but rather replaces the entire premise of it. Instead of retrieving content that was pre-recorded by someone else, AI generates it from scratch, in real time, calibrated to your exact context, your specific intent, the precise ground truth of that moment. The same question asked twice gets two different answers, both tailored to what the system knows about you right now. There is no file being pulled or a pre-recorded version, the content is being synthesized on the fly from a compressed model of human knowledge, shaped to fit exactly what you need. The implications of this for the companies that built the retrieval era are profound and already starting to show. Google's click-through rates on organic search results have dropped 61% since AI Overviews rolled out, because users are getting answers directly instead of clicking through to files. Gartner projects traditional search engine query volume drops 25% by the end of 2026 as users migrate to generative interfaces. And yet this is exactly what Jensen predicted, in the old world, the computing bottleneck was storage and retrieval, you needed hard drives, bandwidth, and CDNs. In the new world, the bottleneck is computation, you need the raw processing power to generate tokens at scale, millions of times per second, for millions of simultaneous users. Inference computing demand has grown roughly ten thousand times in the last two years alone. That shift is precisely why Nvidia's revenue opportunity forecast just jumped from $500 billion through 2026 to $1 trillion through 2027. The retrieval era needed CPUs and storage and the generative era needs GPUs, token factories, and inference infrastructure at a scale never built before and Nvidia builds the engine underneath all of it. Jensen has been making this argument since 2024. Most people wrote it off as a chip salesman talking his book but two years later, it's the architecture of the entire industry.

Milk Road AI

17,911 просмотров • 4 месяцев назад

Thermodynamic computing is here There is a new computing paradigm emerging from the noise, and its arrival may be as significant as the dawn of deep learning or the advent of cloud virtualization. A new company, Extropic, has just launched its first thermodynamic computer, a device they call a TSU, or Thermal Sampling Unit. While the web is already filling with deep technical dives, what’s more important for most of us is building a clear intuition for what this technology is, how it’s fundamentally different from anything that’s come before, and why it’s generating so much excitement. This isn’t just another chip; it’s a new way to think about computation itself. Seeing is Believing: Solving Puzzles in One Shot To understand what a TSU does, let’s look at two classic, notoriously difficult computer science problems: Sudoku and the Eight Queens problem. When you or I solve a Sudoku, we use a process of sequential logic, guess-and-check, and backtracking. We make an assumption, follow its logical conclusion, and if we hit a dead end, we erase and try again. A classical computer does the same, just much faster. A TSU, however, approaches this in a completely different way. Using a TSU simulator, one can “program” the problem by first clamping the known values—the clues already on the board. Then, you program in the constraints: no duplicate numbers in any row, column, or 3x3 square. With the problem thus defined, the TSU doesn’t “search” for a solution; it anneals one. In a single computational step, the solution simply emerges, backfilling all the empty squares correctly. The same principle applies to the Eight Queens problem, a challenge to place eight queens on a chessboard so that none can attack any other. This is a complex combinatorial problem with 92 distinct solutions. A classical computer would have to iteratively search for these. A TSU, by contrast, can be programmed with the constraints (the “anti-affinity” between queens on the same row, column, or diagonal) and then set to sample the “solution space.” In this context, a valid solution is one with a “problem energy” of zero. The TSU’s physical nature allows it to naturally find these zero-energy states. A simulation of this process shows the TSU discovering all 92 unique solutions, demonstrating its ability to not just find an answer, but to explore the entire landscape of all correct answers. This is a fundamentally new approach, one that bypasses the brute-force, iterative methods we’ve relied on for decades. The Physics of Computation: Using Noise, Not Fighting It This new power comes from a radical design philosophy. For the last 70 years, computing has been about one thing: order. We build chips that are deterministic, logical, and precise. The great enemy has always been noise, heat, and randomness. We spend billions on cooling and error correction to eliminate these very things. Quantum computing, in many ways, is the ultimate expression of this, requiring temperatures near absolute zero to eliminate all thermal noise and achieve quantum coherence. Thermodynamic computing is the polar opposite. It doesn’t fight the noise; it uses it. The TSU is built on the understanding that the natural, stochastic noise from “leaky” transistors—the very randomness we’ve tried to engineer out of existence—is itself a powerful computational resource. Think of it this way: a GPU, which is central to today’s AI, has to simulate noise. When a generative AI model creates a new image or sentence, it’s using complex algorithms to fake randomness. The TSU doesn’t need to fake it; it harnesses the actual physical randomness of thermodynamics. It is a piece of hardware that directly computes with probability. This makes it a hybrid, sitting somewhere between a purely analog computer (which might use light or sound waves to compute) and a digital GPU. It’s a physical device that leverages the laws of physics itself to find solutions, rather than just using logic gates to simulate them. From a Lost Hiker to a Million Bouncy Balls Perhaps the best way to build intuition is with a metaphor. Imagine that solving a complex optimization problem is like trying to find the lowest point of altitude in a 100-square-mile mountainous landscape. Classical computing, using an algorithm like gradient descent, is like being a single hiker dropped into this landscape at night. You have no map or satellite view. All you have is an altimeter and the sensation of the slope under your feet. You can only take one step at a time, always walking downhill, hoping you don’t get stuck in a small local valley when the true, lowest canyon is miles away. Thermodynamic computing is a completely different approach. It’s like having a million bouncy balls and a helicopter. You drop all million balls simultaneously across the entire 100-square-mile landscape. Then, you “turn on an earthquake,” shaking the entire system. The balls bounce and jostle, but as the shaking (the “annealing”) subsides, where do they all end up? They naturally settle into the lowest points. The balls that collect in the deepest valley represent the optimal solution. The TSU is, in essence, a physical device for dropping those million balls at once and letting the laws of thermodynamics find the lowest “energy” state for you, all at the same time. Beyond Puzzles: The Real-World Impact This is far more than just a clever way to solve brain teasers. This ability to instantly find the lowest energy state for a complex, constrained system has staggering real-world applications. One of the most immediate is protein folding. Companies like Google’s DeepMind have made incredible progress with AI like AlphaFold, which predicts protein structures. But this is still a predictive model trained on existing data. A TSU could potentially solve the folding problem directly, treating the protein as a system of atomic affinities and repulsions and finding its most stable, lowest-energy configuration almost instantaneously. This could revolutionize drug discovery and materials science. An even more profound possibility lies in nuclear fusion. One of the greatest engineering challenges in history is controlling the superheated plasma within a tokamak reactor. This requires shaping unimaginably complex magnetic containment fields in real-time to prevent the plasma from touching the reactor walls. This is a real-time optimization problem so complex it’s currently beyond our capabilities. A TSU, however, could be fast enough. Its ability to compute with electricity itself, rather than abstracting the problem through layers of software, might allow it to update the magnetic fields fast enough to stabilize the fusion reaction. One could even imagine a future where thermodynamic computing elements are built directly into the tokamak’s walls, allowing the reactor to physically and intelligently react to the plasma’s state in real time. A ‘GPT-2 Moment’ for a New Era It’s easy to become numb to hype, but what we are witnessing with the TSU feels different. This is what you might call a “GPT-2 moment.” For those who were there, GPT-2 was the first generative AI model that wasn’t just a toy; it was the first time you could play with it at home and see the spark of true generative intelligence. It was the precursor that pointed directly to the GPT-3 and ChatGPT revolution that has since changed the world. This TSU has that same feel. It’s the “SDK” for a new computing paradigm. This technology is as different from classical computing as quantum computing is, but with a critical difference: a team of 15 built this in two years, and it runs at room temperature on your desk. Quantum computing has seen decades of work and billions in funding, and it still hasn’t produced a commercially viable, scalable machine. The TSU is here now. Based on a two-decade-long career at the cutting edge of technology—from seeing the obvious future of virtualization in 2007 to an early conviction in deep learning and GPT—this has all the same hallmarks of a fundamental, world-changing shift. We are not just building faster calculators; we are learning to compute with the universe itself. Pay close attention to this. This is the next big thing.
18:01

Thermodynamic computing is here There is a new computing paradigm emerging from the noise, and its arrival may be as significant as the dawn of deep learning or the advent of cloud virtualization. A new company, Extropic, has just launched its first thermodynamic computer, a device they call a TSU, or Thermal Sampling Unit. While the web is already filling with deep technical dives, what’s more important for most of us is building a clear intuition for what this technology is, how it’s fundamentally different from anything that’s come before, and why it’s generating so much excitement. This isn’t just another chip; it’s a new way to think about computation itself. Seeing is Believing: Solving Puzzles in One Shot To understand what a TSU does, let’s look at two classic, notoriously difficult computer science problems: Sudoku and the Eight Queens problem. When you or I solve a Sudoku, we use a process of sequential logic, guess-and-check, and backtracking. We make an assumption, follow its logical conclusion, and if we hit a dead end, we erase and try again. A classical computer does the same, just much faster. A TSU, however, approaches this in a completely different way. Using a TSU simulator, one can “program” the problem by first clamping the known values—the clues already on the board. Then, you program in the constraints: no duplicate numbers in any row, column, or 3x3 square. With the problem thus defined, the TSU doesn’t “search” for a solution; it anneals one. In a single computational step, the solution simply emerges, backfilling all the empty squares correctly. The same principle applies to the Eight Queens problem, a challenge to place eight queens on a chessboard so that none can attack any other. This is a complex combinatorial problem with 92 distinct solutions. A classical computer would have to iteratively search for these. A TSU, by contrast, can be programmed with the constraints (the “anti-affinity” between queens on the same row, column, or diagonal) and then set to sample the “solution space.” In this context, a valid solution is one with a “problem energy” of zero. The TSU’s physical nature allows it to naturally find these zero-energy states. A simulation of this process shows the TSU discovering all 92 unique solutions, demonstrating its ability to not just find an answer, but to explore the entire landscape of all correct answers. This is a fundamentally new approach, one that bypasses the brute-force, iterative methods we’ve relied on for decades. The Physics of Computation: Using Noise, Not Fighting It This new power comes from a radical design philosophy. For the last 70 years, computing has been about one thing: order. We build chips that are deterministic, logical, and precise. The great enemy has always been noise, heat, and randomness. We spend billions on cooling and error correction to eliminate these very things. Quantum computing, in many ways, is the ultimate expression of this, requiring temperatures near absolute zero to eliminate all thermal noise and achieve quantum coherence. Thermodynamic computing is the polar opposite. It doesn’t fight the noise; it uses it. The TSU is built on the understanding that the natural, stochastic noise from “leaky” transistors—the very randomness we’ve tried to engineer out of existence—is itself a powerful computational resource. Think of it this way: a GPU, which is central to today’s AI, has to simulate noise. When a generative AI model creates a new image or sentence, it’s using complex algorithms to fake randomness. The TSU doesn’t need to fake it; it harnesses the actual physical randomness of thermodynamics. It is a piece of hardware that directly computes with probability. This makes it a hybrid, sitting somewhere between a purely analog computer (which might use light or sound waves to compute) and a digital GPU. It’s a physical device that leverages the laws of physics itself to find solutions, rather than just using logic gates to simulate them. From a Lost Hiker to a Million Bouncy Balls Perhaps the best way to build intuition is with a metaphor. Imagine that solving a complex optimization problem is like trying to find the lowest point of altitude in a 100-square-mile mountainous landscape. Classical computing, using an algorithm like gradient descent, is like being a single hiker dropped into this landscape at night. You have no map or satellite view. All you have is an altimeter and the sensation of the slope under your feet. You can only take one step at a time, always walking downhill, hoping you don’t get stuck in a small local valley when the true, lowest canyon is miles away. Thermodynamic computing is a completely different approach. It’s like having a million bouncy balls and a helicopter. You drop all million balls simultaneously across the entire 100-square-mile landscape. Then, you “turn on an earthquake,” shaking the entire system. The balls bounce and jostle, but as the shaking (the “annealing”) subsides, where do they all end up? They naturally settle into the lowest points. The balls that collect in the deepest valley represent the optimal solution. The TSU is, in essence, a physical device for dropping those million balls at once and letting the laws of thermodynamics find the lowest “energy” state for you, all at the same time. Beyond Puzzles: The Real-World Impact This is far more than just a clever way to solve brain teasers. This ability to instantly find the lowest energy state for a complex, constrained system has staggering real-world applications. One of the most immediate is protein folding. Companies like Google’s DeepMind have made incredible progress with AI like AlphaFold, which predicts protein structures. But this is still a predictive model trained on existing data. A TSU could potentially solve the folding problem directly, treating the protein as a system of atomic affinities and repulsions and finding its most stable, lowest-energy configuration almost instantaneously. This could revolutionize drug discovery and materials science. An even more profound possibility lies in nuclear fusion. One of the greatest engineering challenges in history is controlling the superheated plasma within a tokamak reactor. This requires shaping unimaginably complex magnetic containment fields in real-time to prevent the plasma from touching the reactor walls. This is a real-time optimization problem so complex it’s currently beyond our capabilities. A TSU, however, could be fast enough. Its ability to compute with electricity itself, rather than abstracting the problem through layers of software, might allow it to update the magnetic fields fast enough to stabilize the fusion reaction. One could even imagine a future where thermodynamic computing elements are built directly into the tokamak’s walls, allowing the reactor to physically and intelligently react to the plasma’s state in real time. A ‘GPT-2 Moment’ for a New Era It’s easy to become numb to hype, but what we are witnessing with the TSU feels different. This is what you might call a “GPT-2 moment.” For those who were there, GPT-2 was the first generative AI model that wasn’t just a toy; it was the first time you could play with it at home and see the spark of true generative intelligence. It was the precursor that pointed directly to the GPT-3 and ChatGPT revolution that has since changed the world. This TSU has that same feel. It’s the “SDK” for a new computing paradigm. This technology is as different from classical computing as quantum computing is, but with a critical difference: a team of 15 built this in two years, and it runs at room temperature on your desk. Quantum computing has seen decades of work and billions in funding, and it still hasn’t produced a commercially viable, scalable machine. The TSU is here now. Based on a two-decade-long career at the cutting edge of technology—from seeing the obvious future of virtualization in 2007 to an early conviction in deep learning and GPT—this has all the same hallmarks of a fundamental, world-changing shift. We are not just building faster calculators; we are learning to compute with the universe itself. Pay close attention to this. This is the next big thing.

David Shapiro (L/0)

83,649 просмотров • 10 месяцев назад

HERMES AGENT SUPPORTS 300+ MODELS. PICKING THE RIGHT ONE PER TASK IS THE DIFFERENCE BETWEEN $5/MONTH AND $50. STARTING OUT: Claude Sonnet 4.6. official recommendation from Nous Research. "the model this project was built and tested with." strong reasoning. reliable tool calling. mid-range pricing. PREMIUM TIER: Claude Opus 4.8. best coding benchmarks available. self-correcting reasoning. catches its own mistakes. 1M context. use for demanding tasks where quality matters. GPT-5.5. #1 Chatbot Arena. #1 GPQA Diamond reasoning (94.1%). #1 creative writing. 2M context. handles entire codebases in one pass. Grok 4.30. the only frontier model with live X firehose access. real-time social data, breaking news, market sentiment. connects via Grok OAuth. no separate API key. Grok-Composer-2.5-Fast (v0.17.0). Cursor's coding model. 200K context. available through your Grok subscription via OAuth. no extra cost if you already pay for Grok. MID-RANGE TIER: Claude Sonnet 4.6. best balance of quality and cost for daily use. strongest prose and tool calling in this tier. Gemini 2.5 Pro. Google Search grounding built in. cites sources. verifies claims. pulls current data. 2M context. best for research-heavy workflows. GPT-4.1. reliable tool calling. solid general reasoning. good middle ground when you need OpenAI compatibility. BUDGET TIER: Claude Haiku 4.5. fastest Anthropic model. cheapest paid Claude option. strong at classification, routing, simple queries. use for auxiliary tasks: compression, vision, web extraction, approval scoring. DeepSeek V4. best cost-to-quality ratio in the market. 90% cache discount on repeated context. use for sub-agents and bulk parallel work. DeepSeek V4 Flash. cheapest paid model worth using. 1M context. MIT license. self-hostable. use for cron jobs, monitoring, routine searches. MiniMax M3. Nous Research and MiniMax collaborating on optimization. 1M context via lightning attention. 59% SWE-Bench Pro. beats several premium models on coding. one of the most-used models inside Hermes. FREE / LOCAL: Qwen 3.5 27B via Ollama. 16GB VRAM. reliable tool calling. best free local model for Hermes as of mid-2026. Qwen 3 8B. 8GB VRAM. fits a $7 VPS. handles routine tasks at zero API cost. Llama 4 Maverick. best open-weight tool calling. 1M context. needs more VRAM but strongest local option. HOW TO ASSIGN MODELS: main model: Desktop app / Dashboard → Models → switch sub-agent model: set in Desktop app, Dashboard, or config.yaml: delegation: model: "deepseek/deepseek-v4" auxiliary models (compression, vision, web extract): Desktop app / Dashboard → Models → Auxiliary Haiku 4.5 or Gemini Flash work well here. saves significantly when your main model is premium. per-profile: each Hermes profile gets its own model. Scout on DeepSeek. Analyst on Sonnet. Briefer on budget model. Coder on Opus. per-cron-job: pin a specific model to any cron job. morning brief on Haiku. deep research on Sonnet. monitoring on DeepSeek Flash. each job uses only the model it needs. per-session: /model deepseek/deepseek-v4-flash hot-swap mid-conversation. no restart needed. FALLBACK CHAINS: if your primary model is unavailable, Hermes automatically switches to the next provider. rate limit or server error = next model in the chain. no failed runs. no manual intervention. set in Desktop app, Dashboard, or config.yaml: fallback_providers: - openrouter - nous - codex PROVIDER PATHS: OPENROUTER: 300+ models under one API key. pay per token. most flexible. NOUS PORTAL: 300+ models + Tool Gateway (web search, image gen, TTS, browser). one OAuth. one subscription. 10% off token-billed providers. CHATGPT SUB: GPT-5.5 + Grok via OAuth. included tokens with $20 subscription. OLLAMA: free. local. private. zero API cost. your hardware only. mix providers across profiles and tasks. Scout on OpenRouter. Analyst on Nous Portal. Coder on ChatGPT sub. Monitor on Ollama. THE RULE: premium for work that needs deep reasoning. mid-range for daily driver tasks. budget for volume and background work. free for monitoring and routine jobs. pricing changes fast. check openrouter ai for current rates before committing. Which is your favourite model and for what task? full 15 levels breakdown in the article 👇
0:51

HERMES AGENT SUPPORTS 300+ MODELS. PICKING THE RIGHT ONE PER TASK IS THE DIFFERENCE BETWEEN $5/MONTH AND $50. STARTING OUT: Claude Sonnet 4.6. official recommendation from Nous Research. "the model this project was built and tested with." strong reasoning. reliable tool calling. mid-range pricing. PREMIUM TIER: Claude Opus 4.8. best coding benchmarks available. self-correcting reasoning. catches its own mistakes. 1M context. use for demanding tasks where quality matters. GPT-5.5. #1 Chatbot Arena. #1 GPQA Diamond reasoning (94.1%). #1 creative writing. 2M context. handles entire codebases in one pass. Grok 4.30. the only frontier model with live X firehose access. real-time social data, breaking news, market sentiment. connects via Grok OAuth. no separate API key. Grok-Composer-2.5-Fast (v0.17.0). Cursor's coding model. 200K context. available through your Grok subscription via OAuth. no extra cost if you already pay for Grok. MID-RANGE TIER: Claude Sonnet 4.6. best balance of quality and cost for daily use. strongest prose and tool calling in this tier. Gemini 2.5 Pro. Google Search grounding built in. cites sources. verifies claims. pulls current data. 2M context. best for research-heavy workflows. GPT-4.1. reliable tool calling. solid general reasoning. good middle ground when you need OpenAI compatibility. BUDGET TIER: Claude Haiku 4.5. fastest Anthropic model. cheapest paid Claude option. strong at classification, routing, simple queries. use for auxiliary tasks: compression, vision, web extraction, approval scoring. DeepSeek V4. best cost-to-quality ratio in the market. 90% cache discount on repeated context. use for sub-agents and bulk parallel work. DeepSeek V4 Flash. cheapest paid model worth using. 1M context. MIT license. self-hostable. use for cron jobs, monitoring, routine searches. MiniMax M3. Nous Research and MiniMax collaborating on optimization. 1M context via lightning attention. 59% SWE-Bench Pro. beats several premium models on coding. one of the most-used models inside Hermes. FREE / LOCAL: Qwen 3.5 27B via Ollama. 16GB VRAM. reliable tool calling. best free local model for Hermes as of mid-2026. Qwen 3 8B. 8GB VRAM. fits a $7 VPS. handles routine tasks at zero API cost. Llama 4 Maverick. best open-weight tool calling. 1M context. needs more VRAM but strongest local option. HOW TO ASSIGN MODELS: main model: Desktop app / Dashboard → Models → switch sub-agent model: set in Desktop app, Dashboard, or config.yaml: delegation: model: "deepseek/deepseek-v4" auxiliary models (compression, vision, web extract): Desktop app / Dashboard → Models → Auxiliary Haiku 4.5 or Gemini Flash work well here. saves significantly when your main model is premium. per-profile: each Hermes profile gets its own model. Scout on DeepSeek. Analyst on Sonnet. Briefer on budget model. Coder on Opus. per-cron-job: pin a specific model to any cron job. morning brief on Haiku. deep research on Sonnet. monitoring on DeepSeek Flash. each job uses only the model it needs. per-session: /model deepseek/deepseek-v4-flash hot-swap mid-conversation. no restart needed. FALLBACK CHAINS: if your primary model is unavailable, Hermes automatically switches to the next provider. rate limit or server error = next model in the chain. no failed runs. no manual intervention. set in Desktop app, Dashboard, or config.yaml: fallback_providers: - openrouter - nous - codex PROVIDER PATHS: OPENROUTER: 300+ models under one API key. pay per token. most flexible. NOUS PORTAL: 300+ models + Tool Gateway (web search, image gen, TTS, browser). one OAuth. one subscription. 10% off token-billed providers. CHATGPT SUB: GPT-5.5 + Grok via OAuth. included tokens with $20 subscription. OLLAMA: free. local. private. zero API cost. your hardware only. mix providers across profiles and tasks. Scout on OpenRouter. Analyst on Nous Portal. Coder on ChatGPT sub. Monitor on Ollama. THE RULE: premium for work that needs deep reasoning. mid-range for daily driver tasks. budget for volume and background work. free for monitoring and routine jobs. pricing changes fast. check openrouter ai for current rates before committing. Which is your favourite model and for what task? full 15 levels breakdown in the article 👇

YanXbt

17,138 просмотров • 2 месяцев назад

Over the past two years, AI video models have been competing on realism, resolution, and duration. But no matter how impressive the results look, we remain passive viewers: we press play, watch the clip, and it ends. AlayaWorld Alaya Lab is attempting something fundamentally different. Instead of generating a fixed video, it generates a world that continues to unfold as you move through it. These three demos show the same journey toward a green village rendered in three distinct styles: photorealistic, oil painting, and line art. As the camera moves forward, the model continues generating the road, fences, trees, and distant village. This is not simply an existing video with different filters applied. The environment is generated continuously along the camera trajectory, allowing the scene to develop as the user explores it. AlayaWorld streams video at 720p and 24 FPS while supporting camera movement and viewpoint control. The real breakthrough is not just image quality. Once generation becomes fast enough to respond within an interactive loop, the user is no longer merely watching a video. They become a participant inside the generated world. The world can also respond to new instructions. During generation, users can introduce prompts that trigger spells, summon characters, create explosions, or transform the environment. Most video models follow an initial prompt and produce a predetermined clip. AlayaWorld can respond to changing intent while the world is still running, allowing subsequent events to evolve according to the user’s commands. Generating an attractive frame is relatively easy. Maintaining a coherent world over time is much harder. As a video model repeatedly predicts the next frame, small errors can accumulate until roads, buildings, and objects begin to distort or disappear. AlayaWorld combines spatial memory with compressed historical context, helping the model remember both where things are and what has already happened. This enables stable generation lasting more than one minute while improving consistency when the camera leaves an area and later returns. This may be the next step for AI video: not simply generating a longer movie, but generating a world that can be explored, changed, and interacted with. AlayaWorld is developed by Alaya Lab. The team is progressively releasing its inference code, training code, and datasets, with an online experience expected to launch near the end of the month. Project page:
0:20

Over the past two years, AI video models have been competing on realism, resolution, and duration. But no matter how impressive the results look, we remain passive viewers: we press play, watch the clip, and it ends. AlayaWorld Alaya Lab is attempting something fundamentally different. Instead of generating a fixed video, it generates a world that continues to unfold as you move through it. These three demos show the same journey toward a green village rendered in three distinct styles: photorealistic, oil painting, and line art. As the camera moves forward, the model continues generating the road, fences, trees, and distant village. This is not simply an existing video with different filters applied. The environment is generated continuously along the camera trajectory, allowing the scene to develop as the user explores it. AlayaWorld streams video at 720p and 24 FPS while supporting camera movement and viewpoint control. The real breakthrough is not just image quality. Once generation becomes fast enough to respond within an interactive loop, the user is no longer merely watching a video. They become a participant inside the generated world. The world can also respond to new instructions. During generation, users can introduce prompts that trigger spells, summon characters, create explosions, or transform the environment. Most video models follow an initial prompt and produce a predetermined clip. AlayaWorld can respond to changing intent while the world is still running, allowing subsequent events to evolve according to the user’s commands. Generating an attractive frame is relatively easy. Maintaining a coherent world over time is much harder. As a video model repeatedly predicts the next frame, small errors can accumulate until roads, buildings, and objects begin to distort or disappear. AlayaWorld combines spatial memory with compressed historical context, helping the model remember both where things are and what has already happened. This enables stable generation lasting more than one minute while improving consistency when the camera leaves an area and later returns. This may be the next step for AI video: not simply generating a longer movie, but generating a world that can be explored, changed, and interacted with. AlayaWorld is developed by Alaya Lab. The team is progressively releasing its inference code, training code, and datasets, with an online experience expected to launch near the end of the month. Project page:

Rachel🥥

78,293 просмотров • 1 месяц назад

A banana in January in New York floods your mitochondria with deuterium. Your body has no tools to handle it. Dr. Laszlo Boros — former professor of pediatrics at the UCLA School of Medicine & pioneer of deutonomics — explains why seasonal & local eating isn't just a dietary preference. It's a fundamental requirement for mitochondrial function. Three independent mechanisms explain why. 1) Sunlight and photon pressure: Tropical fruits are naturally high in deuterium — the heavy isotope of hydrogen that causes ATP synthase nanomotors inside your mitochondria to stutter and break. In equatorial regions, high-intensity red and infrared sunlight penetrates the body and decreases the viscosity of water inside mitochondria — allowing the nanomotors to keep spinning despite the deuterium load. Eat that same banana in a dark New York winter — without the corresponding sunlight — and your mitochondria receive the heavy fuel without the light needed to process it. The nanomotors stall. 2) Microbiome desynchronization: Your gut microbiome is your primary deuterium filter. Here's the mechanism most people miss: Bacteria actively collect deuterium to fuel their own division. They run their nanomotors in reverse — pumping clean protons out while trapping heavy deuterons inside their cells. As they ferment your food, they strip out the deuterium and release deuterium-depleted metabolites — short-chain fatty acids and ketone bodies — back into your gut for clean energy production. The trapped deuterium gets excreted in your stool. But this filtering mechanism only works when your microbiome is adapted to the food you're eating. Bacteria are highly specialized. They only efficiently metabolize a narrow range of substrates. When you eat a consistent local diet — your microbiome develops a stable tailored population that knows exactly how to extract deuterium from those specific local foods. When you introduce an imported tropical fruit in winter — your gut bacteria are caught off guard. They haven't adapted to this foreign substrate. They can't ferment it efficiently. They can't trap the deuterium fast enough. It slips past the gut's mucosal barrier directly into your circulation — and into your mitochondria. 3) Nanomotor stutter and metabolic crowding: Inside your mitochondria are ATP synthase nanomotors — spinning at up to ~9,000 rotations per minute to pump protons and produce energy. A deuteron is twice as large and twice as heavy as a normal proton. When it enters these fast-spinning motors — it acts like a medicine ball thrown into a precision engine. It becomes stuck. The nanomotors stutter and break. The consequence is metabolic crowding. With the motors destroyed, protons can no longer return to the mitochondrial matrix to mix with oxygen and form metabolic water. Complete biological combustion stops. Just like an engine choked with fuel but lacking a working exhaust — your mitochondria can no longer fully burn incoming carbohydrates, fats, and proteins into their natural end products of carbon dioxide and water. The unburned fuel backs up and piles up inside your cells. Your body stores it as visceral fat, excessive glycogen, or abnormal proteins. This is metabolic crowding. And it is the biochemical root of obesity, diabetes, and cancer. Boros: "When you walk into a department store and you see those shiny apples and watermelons from wherever they're from — it's really not your food. First of all, it doesn't grow there, especially not in that season. And when you eat it, you don't have the light exposure, the oxygen partial pressure, and you name it." Eating locally and seasonally isn't a wellness trend. It's what your mitochondria were built for.
1:59

A banana in January in New York floods your mitochondria with deuterium. Your body has no tools to handle it. Dr. Laszlo Boros — former professor of pediatrics at the UCLA School of Medicine & pioneer of deutonomics — explains why seasonal & local eating isn't just a dietary preference. It's a fundamental requirement for mitochondrial function. Three independent mechanisms explain why. 1) Sunlight and photon pressure: Tropical fruits are naturally high in deuterium — the heavy isotope of hydrogen that causes ATP synthase nanomotors inside your mitochondria to stutter and break. In equatorial regions, high-intensity red and infrared sunlight penetrates the body and decreases the viscosity of water inside mitochondria — allowing the nanomotors to keep spinning despite the deuterium load. Eat that same banana in a dark New York winter — without the corresponding sunlight — and your mitochondria receive the heavy fuel without the light needed to process it. The nanomotors stall. 2) Microbiome desynchronization: Your gut microbiome is your primary deuterium filter. Here's the mechanism most people miss: Bacteria actively collect deuterium to fuel their own division. They run their nanomotors in reverse — pumping clean protons out while trapping heavy deuterons inside their cells. As they ferment your food, they strip out the deuterium and release deuterium-depleted metabolites — short-chain fatty acids and ketone bodies — back into your gut for clean energy production. The trapped deuterium gets excreted in your stool. But this filtering mechanism only works when your microbiome is adapted to the food you're eating. Bacteria are highly specialized. They only efficiently metabolize a narrow range of substrates. When you eat a consistent local diet — your microbiome develops a stable tailored population that knows exactly how to extract deuterium from those specific local foods. When you introduce an imported tropical fruit in winter — your gut bacteria are caught off guard. They haven't adapted to this foreign substrate. They can't ferment it efficiently. They can't trap the deuterium fast enough. It slips past the gut's mucosal barrier directly into your circulation — and into your mitochondria. 3) Nanomotor stutter and metabolic crowding: Inside your mitochondria are ATP synthase nanomotors — spinning at up to ~9,000 rotations per minute to pump protons and produce energy. A deuteron is twice as large and twice as heavy as a normal proton. When it enters these fast-spinning motors — it acts like a medicine ball thrown into a precision engine. It becomes stuck. The nanomotors stutter and break. The consequence is metabolic crowding. With the motors destroyed, protons can no longer return to the mitochondrial matrix to mix with oxygen and form metabolic water. Complete biological combustion stops. Just like an engine choked with fuel but lacking a working exhaust — your mitochondria can no longer fully burn incoming carbohydrates, fats, and proteins into their natural end products of carbon dioxide and water. The unburned fuel backs up and piles up inside your cells. Your body stores it as visceral fat, excessive glycogen, or abnormal proteins. This is metabolic crowding. And it is the biochemical root of obesity, diabetes, and cancer. Boros: "When you walk into a department store and you see those shiny apples and watermelons from wherever they're from — it's really not your food. First of all, it doesn't grow there, especially not in that season. And when you eat it, you don't have the light exposure, the oxygen partial pressure, and you name it." Eating locally and seasonally isn't a wellness trend. It's what your mitochondria were built for.

no.mind

117,923 просмотров • 3 месяцев назад

$IONQ "The world still massively underestimates just how disruptive it's going to be." Chris Ballance IonQ President of Quantum Computing laid out the whole picture with Kearney's Brent Smolinski. Start to finish: What it is → Quantum computers run on quantum physics, not classical logic - for Ballance, the most powerful form of computing the laws of physics allow. They solve in minutes what a classical machine couldn't crack in the lifetime of the universe. Where we are → "The end of the beginning." Real systems exist, you can buy one from IonQ today, and the field is speed-running the computing revolution. The race now: who scales the best platform the fastest. The value comes in three eras → - Early: problems classical can't touch - chemistry & drug discovery (with AstraZeneca), crash-analysis simulation (with Ansys). - Middle: familiar work, but faster, better or far less energy - AI fine-tuning, most likely hybrid: a GPU farm and a quantum computer side by side, more than the sum of their parts. - Late: unknown. The killer applications are never the ones you expect. Quantum advantage → Not a benchmark stunt - a better solution per dollar invested in quantum than classical. Hard to spot, but already real for certain early problems. The economics → His sharpest line: compute is now just a markup on electricity. With a fixed budget, the question is classical or quantum - and some of the first quantum wins won't be faster, just orders of magnitude cheaper. The architectures → Superconducting (IBM, Google): first-mover lead and standard chip fabs - but chips chilled to a thousandth of a degree above absolute zero, huge energy-hungry refrigeration, and a quantum chip "three orders of magnitude harder" than Intel's toughest. It loses coherence fast, too: many redundant qubits, far bigger machines. Trapped ions (IonQ): individual atoms - and an atom is "guaranteed perfect across the universe." No fab variation, far lower error rates, no exotic cooling. The atoms are run by an ordinary classical chip, so IonQ rides the trillion-dollar semiconductor industry instead of inventing a quantum chip. (Oxford Ionics' Electronic Qubit Control, SkyWater foundry) Why it's green → A future million-qubit machine is about a dozen racks drawing minuscule power - orders of magnitude less than a large AI data center. Classical can still gain 10–100×, but not the orders of magnitude quantum unlocks. His call: within ~10 years, some 100-megawatt NVIDIA clusters could sit vacant. Quick-fire → - Most over-hyped: changing biology. - Most underestimated risk: integrating into real customer workflows. - First to adopt: finance ) portfolio analysis & fraud prevention. - Most exciting: the speed of change over the next 24 months. The personal why → What gets him out of bed: reinventing how we think about computation and the belief that the world still underestimates how disruptive this will be. For leaders → Quantum computing is here now. Adopting any new tech takes 2-3 years, so the moment to start isn't next year it's now, so you're ready when the hardware lands. Full conversation below ↓ $IONQ #IonQ #Quantum
17:04

$IONQ "The world still massively underestimates just how disruptive it's going to be." Chris Ballance IonQ President of Quantum Computing laid out the whole picture with Kearney's Brent Smolinski. Start to finish: What it is → Quantum computers run on quantum physics, not classical logic - for Ballance, the most powerful form of computing the laws of physics allow. They solve in minutes what a classical machine couldn't crack in the lifetime of the universe. Where we are → "The end of the beginning." Real systems exist, you can buy one from IonQ today, and the field is speed-running the computing revolution. The race now: who scales the best platform the fastest. The value comes in three eras → - Early: problems classical can't touch - chemistry & drug discovery (with AstraZeneca), crash-analysis simulation (with Ansys). - Middle: familiar work, but faster, better or far less energy - AI fine-tuning, most likely hybrid: a GPU farm and a quantum computer side by side, more than the sum of their parts. - Late: unknown. The killer applications are never the ones you expect. Quantum advantage → Not a benchmark stunt - a better solution per dollar invested in quantum than classical. Hard to spot, but already real for certain early problems. The economics → His sharpest line: compute is now just a markup on electricity. With a fixed budget, the question is classical or quantum - and some of the first quantum wins won't be faster, just orders of magnitude cheaper. The architectures → Superconducting (IBM, Google): first-mover lead and standard chip fabs - but chips chilled to a thousandth of a degree above absolute zero, huge energy-hungry refrigeration, and a quantum chip "three orders of magnitude harder" than Intel's toughest. It loses coherence fast, too: many redundant qubits, far bigger machines. Trapped ions (IonQ): individual atoms - and an atom is "guaranteed perfect across the universe." No fab variation, far lower error rates, no exotic cooling. The atoms are run by an ordinary classical chip, so IonQ rides the trillion-dollar semiconductor industry instead of inventing a quantum chip. (Oxford Ionics' Electronic Qubit Control, SkyWater foundry) Why it's green → A future million-qubit machine is about a dozen racks drawing minuscule power - orders of magnitude less than a large AI data center. Classical can still gain 10–100×, but not the orders of magnitude quantum unlocks. His call: within ~10 years, some 100-megawatt NVIDIA clusters could sit vacant. Quick-fire → - Most over-hyped: changing biology. - Most underestimated risk: integrating into real customer workflows. - First to adopt: finance ) portfolio analysis & fraud prevention. - Most exciting: the speed of change over the next 24 months. The personal why → What gets him out of bed: reinventing how we think about computation and the belief that the world still underestimates how disruptive this will be. For leaders → Quantum computing is here now. Adopting any new tech takes 2-3 years, so the moment to start isn't next year it's now, so you're ready when the hardware lands. Full conversation below ↓ $IONQ #IonQ #Quantum

TechInnovation

26,136 просмотров • 2 месяцев назад

History is made: Fine structure mystery solved? /🧵 UPDATE: My model may have solved an outstanding question in physics: the origin of the fine structure constant. I found a robust source and it works even with some tuning within -3% to 7% over a massive range of non-linear fields. What is the fine structure constant? Watch the video below and you'll find out. Essentially its a mysterious constant that occurs in atomic and subatomic physics that has no unit. Countless people have tried to find a reason for it, and most have turned to numerology. I did something that only could work in this age of LLMs and someone who is a motivated expert in the field. Did a massive paper search, found the material in 10 minutes, aligned everything, then had it double check for me. Note that I wasn't looking for it. It occurred to me by accident when I was developing my bilinear principle of electromagnetic interaction. Within an hour, I had a value for it. My idea was simple: apply my non-linear soliton model to the electron in a way that makes my current x current interaction make sense not just at the atomic level but the subatomic level. Look at E = mc^2. It's the same as E = (sqrt(m) c)(sqrt(m) c). If sqrt(m) could be scaled to a charge, then you could interpret it as two scaled currents multiplying against each other. This is almost identical to the equation for the energy contained within an inductor L with a current I running through it: E = 0.5 L I^2. So far, sketchy right? Here's the thing, vortexes are solitons and they can exist in superfluids -- they even have quantised "Noether charge". They acquire a mass from their vorticity, have an energy associated with them and can move at any speed inside the medium with a different speed. Exactly like electrons! So my idea was to map the electron exactly to these vortices. If I could predict the mass of the electron, I could actually finally connect mass to electromagentism properly (Planck's argument is elegant but indirect). I used dimensional analysis to do this. It took a few tries to get it right and I had it checked by 10 different instances of the highest powered LLMs. With this first order approximation I got within 1/4th of the mass. It was almost exactly 1/4th... so I realised, I had to use a double cover to make it like SU(2). After another half an hour of research, I felt confident in using something like Dirac's scissor to do it. A kind of knot within the electron. It got me within 1.2% of the mass of the electron... but there was a problem, the mass of the electron occurred on the other side of the equation. I cringed at myself. Such an amateur mistake, I thought. But the LLM (Opus 4.5) actually corrected me and told me I had just accidentally derived the fine structure constant. Why? Because the mass terms cancelled out, or if one prefers, leave behind a correction ratio. Set that correction ratio and you get a function that implicitly defines the fine structure constant through two "parameters": 1. The actual geometry of the soliton/vortex. 2. The non-linearity of the medium and how it changed the vortex core. I went back and found an equation from friggin' Lord Kelvin, derived in the Victorian era. I then found an analysis from 1970 on the Non-linear Schrodinger Equation (NLSE) applied to exactly this domain but for a larger scale soliton in superfluids -- it didn't matter though because a superfluid and the medium of space are scale free as I had proven in the superconduction part of my paper. In any case plugging these two approximation in got me within 1.2% of the fine structure constant by solving the following implicit equation: 1 = 8 * pi * alpha (Log_e(8/alpha) - alpha_core) Where alpha_core is 1.615 in the NLSE. The most incredible thing? It was a ROBUST value for thin ring vortices. Even if you adjusted the alpha_core from 1.5-2, the values for the fine structure constant only changed between -3% to +7%. I cannot emphasise how incredible this result is -- it means that the actual non-linear equation and the other candidate geometries that reproduce SU(2) can actually get the exact value of the fine structure constant. I don't know of anyone who even approached this problem in this way without making ansatz or postulates. I'm still checking through the math in disbelief. If it's wrong it's going to be beautifully wrong. All LLMs I've ran it through agree with the math, just not the foundations which is expected due to their QED bias. This will be in chapter 11 of my paper. I've already sketched out the full derivation. This SIGNIFICANTLY strengthens an already game changing paper. I promise it'll be the last discovery I include and thank you for your patience. I wrote this full update out because of the significance of this development. Details will be in the paper, even if there was a mistake (it'll be shuffled on its own into the appendix -- but I really hope it all checks out). 💝🥰 /End
15:57

History is made: Fine structure mystery solved? /🧵 UPDATE: My model may have solved an outstanding question in physics: the origin of the fine structure constant. I found a robust source and it works even with some tuning within -3% to 7% over a massive range of non-linear fields. What is the fine structure constant? Watch the video below and you'll find out. Essentially its a mysterious constant that occurs in atomic and subatomic physics that has no unit. Countless people have tried to find a reason for it, and most have turned to numerology. I did something that only could work in this age of LLMs and someone who is a motivated expert in the field. Did a massive paper search, found the material in 10 minutes, aligned everything, then had it double check for me. Note that I wasn't looking for it. It occurred to me by accident when I was developing my bilinear principle of electromagnetic interaction. Within an hour, I had a value for it. My idea was simple: apply my non-linear soliton model to the electron in a way that makes my current x current interaction make sense not just at the atomic level but the subatomic level. Look at E = mc^2. It's the same as E = (sqrt(m) c)(sqrt(m) c). If sqrt(m) could be scaled to a charge, then you could interpret it as two scaled currents multiplying against each other. This is almost identical to the equation for the energy contained within an inductor L with a current I running through it: E = 0.5 L I^2. So far, sketchy right? Here's the thing, vortexes are solitons and they can exist in superfluids -- they even have quantised "Noether charge". They acquire a mass from their vorticity, have an energy associated with them and can move at any speed inside the medium with a different speed. Exactly like electrons! So my idea was to map the electron exactly to these vortices. If I could predict the mass of the electron, I could actually finally connect mass to electromagentism properly (Planck's argument is elegant but indirect). I used dimensional analysis to do this. It took a few tries to get it right and I had it checked by 10 different instances of the highest powered LLMs. With this first order approximation I got within 1/4th of the mass. It was almost exactly 1/4th... so I realised, I had to use a double cover to make it like SU(2). After another half an hour of research, I felt confident in using something like Dirac's scissor to do it. A kind of knot within the electron. It got me within 1.2% of the mass of the electron... but there was a problem, the mass of the electron occurred on the other side of the equation. I cringed at myself. Such an amateur mistake, I thought. But the LLM (Opus 4.5) actually corrected me and told me I had just accidentally derived the fine structure constant. Why? Because the mass terms cancelled out, or if one prefers, leave behind a correction ratio. Set that correction ratio and you get a function that implicitly defines the fine structure constant through two "parameters": 1. The actual geometry of the soliton/vortex. 2. The non-linearity of the medium and how it changed the vortex core. I went back and found an equation from friggin' Lord Kelvin, derived in the Victorian era. I then found an analysis from 1970 on the Non-linear Schrodinger Equation (NLSE) applied to exactly this domain but for a larger scale soliton in superfluids -- it didn't matter though because a superfluid and the medium of space are scale free as I had proven in the superconduction part of my paper. In any case plugging these two approximation in got me within 1.2% of the fine structure constant by solving the following implicit equation: 1 = 8 * pi * alpha (Log_e(8/alpha) - alpha_core) Where alpha_core is 1.615 in the NLSE. The most incredible thing? It was a ROBUST value for thin ring vortices. Even if you adjusted the alpha_core from 1.5-2, the values for the fine structure constant only changed between -3% to +7%. I cannot emphasise how incredible this result is -- it means that the actual non-linear equation and the other candidate geometries that reproduce SU(2) can actually get the exact value of the fine structure constant. I don't know of anyone who even approached this problem in this way without making ansatz or postulates. I'm still checking through the math in disbelief. If it's wrong it's going to be beautifully wrong. All LLMs I've ran it through agree with the math, just not the foundations which is expected due to their QED bias. This will be in chapter 11 of my paper. I've already sketched out the full derivation. This SIGNIFICANTLY strengthens an already game changing paper. I promise it'll be the last discovery I include and thank you for your patience. I wrote this full update out because of the significance of this development. Details will be in the paper, even if there was a mistake (it'll be shuffled on its own into the appendix -- but I really hope it all checks out). 💝🥰 /End

Korobochka (コロボ) 🇦🇺✝️🇷🇺

47,180 просмотров • 9 месяцев назад

What's next for OpenTUI? Here's a technical write-up. Over the last few months OpenTUI gained a lot of stability improvements, new unnecessary but fun features like live audio streaming, and useful features like rendering to the scrollback buffer mixed with a live TUI, called footer mode. Overall the feature set enables building large and complex applications. React and Solid make it super simple and convenient. There is still so much to do though. Three big milestones we have set out to achieve are: - Moving most of the behavioural logic currently living in TypeScript down to the native Zig core - Node compatibility - Optimizing the hell out of primitives like text rendering The render tree mechanisms are currently only usable from TypeScript. Think of the DOM, but controllable like a scene graph. Elements in the render tree are called renderables. They can expose a render method to draw themselves. All renderables are derived from a BaseRenderable. Renderables and the render tree will become native primitives. Building blocks usable from any language bindings. Reducing the TypeScript bindings to a very thin layer, with all the behavioural logic living in the native binary. Moving this down is not just a matter of porting TypeScript classes to Zig. TypeScript currently owns the tree, dirty-state propagation, layout reads, culling, and render ordering. If it still has to walk every node and call into native code for each step, we keep most of the complexity and add FFI overhead. Whole passes and their state need to move together. We took a big step towards this recently by building yoga-layout into the native binary. It exposes part of the official yoga-layout TypeScript package via FFI. Only the API surface that is actually used by OpenTUI. Covered by the test suite of the original yoga-layout package. This already gave a median speedup of ~2.5x, and up to 30x for narrow scenarios. The yoga-layout integration is useful beyond the speedup. Built-in text and editor measurement can now happen entirely in native code during layout instead of calling back into JavaScript. I ran an experiment last month taking this even further, having GPT 5.6 port yoga-layout from C++ to Zig, which gave extremely good results. It would be a burden to maintain right now though, so that's off the table for now. I might come back to it. Simon Klee is working relentlessly on Node compatibility and already has a full Node version of OpenCode running. Node got FFI support in v26.4.0, thanks to help from the Node community, namely Matteo Collina and Paolo Insogna. Behaviour and interfaces seem similar between Node and Bun, but there are some major differences. To get the best performance out of the Node FFI implementation, its usage has to follow some rules. Node has three ways to call native functions: the generic C++/libffi path, the SharedBuffer path, and the V8 Fast API. The generic path converts every argument in Node's C++ layer and then calls the function through libffi. It is flexible, but also the slowest option for frequently called functions. The SharedBuffer path is a middle ground. JavaScript writes scalar values and BigInt pointers into a small per-function buffer, reducing some conversion work. The actual native call still goes through libffi though. Typed arrays used as pointers cannot be packed into this buffer and fall back to the generic path. The path we really want is the V8 Fast API. Node generates a small machine-code trampoline for the exact function signature, allowing optimized JavaScript to call the native function without going through the generic converter or libffi. This only applies to JavaScript-to-native calls. Callbacks from native code into JavaScript still use libffi closures. Getting onto this path is quite strict. A signature can have at most eight arguments and everything must fit into CPU registers. x86-64 Unix systems have room for six GP (general-purpose) and eight FP (floating-point) arguments. AArch64 has room for seven GP and eight FP arguments. Anything that spills onto the stack falls back to a slower path. These are Node fast-path restrictions, not general FFI restrictions. Bun also does not support passing structs by value through its current FFI API. OpenTUI uses bun-ffi-structs to pack ABI-aligned struct data into an ArrayBuffer and passes a pointer instead. Despite the name, the package also works with Node. Pointers need some care too. Typed arrays and ArrayBuffers normally have to be resolved into BigInt addresses first. Eligible functions with exactly one pointer argument get another Fast API entrypoint that can extract the address directly from the buffer. An eligible signature is still not enough. V8 has to optimize a direct call with a fixed number of consistently typed arguments. Wrappers that collect arguments and forward them using spread or Reflect.apply can hide that call shape and keep the function on a slower path. The practical rules are: keep hot signatures within register limits, use direct fixed-arity calls with stable argument types, reuse owned buffers safely, and batch small operations. Then measure the real call site, because eligibility only makes a function fast-capable. We have to design the ABI around these constraints where it makes sense and gives the expected performance improvement. The third big area is text rendering. Today a Text renderable accepts a string, StyledText, or a tree of TextNodes. Before rendering, the TextNode tree is walked and flattened into styled chunks. Those chunks are packed in TypeScript, sent through FFI, copied into a native TextBuffer, and stored in a rope. Styles are represented separately as highlights. A TextBufferView then wraps the rope into visual lines, which are drawn into the visible buffer. This works, but updates are much more expensive than they should be. setStyledText effectively throws away and rebuilds the rope, copies and reparses all text and recreates the style highlights. Changing one TextNode also walks and flattens the complete tree before going through this path again. Text and style segments should instead live directly in the rope and support incremental replacement. Memory ownership is split between retained JavaScript buffers, the native memory registry, rope arenas, wrapping caches, styled-text storage, and highlights. Different operations preserve or reset different parts of that state. This is hard to reason about and can retain memory for much longer than expected. Text storage needs clearer ownership, with fewer lifetimes split across JavaScript and native code. The public API reflects the same split. The t template literal is convenient, but creates another intermediate chunk representation that is mutable, not cached, and not merged. Text also maintains both StyledText content and a special TextNode tree, which do not compose properly. TextNode is only a style scope, not a normal layout primitive, so Text renderables cannot naturally compose inside each other. I think this should become one Text primitive backed directly by rope segments. The template literal API might disappear or become a very thin helper around those native segments. Editing has another temporary layer in TypeScript. Extmarks currently monkey-patch editing operations, scan and adjust all marks after changes, maintain their own undo state, and recreate native highlights. They should become native marks anchored directly in the rope. A proper mark tree, similar to Neovim's marktree, could update marks together with edits, undo, and redo, and provide the foundation for highlights and concealment. Text wrapping has also become too complex. Supporting CJK, emoji, combining characters, ZWJ sequences, tabs, and different terminal width rules currently mixes byte offsets, grapheme indexes, and display-cell columns across several custom algorithms. Dirty views rewrap the complete document. Measurement and drawing can repeat some of the same work. The wrapping implementation needs an overhaul, but the exact shape is still open. The goal is to make Unicode handling easier to maintain, avoid repeated full-document work, and clearly separate byte offsets, graphemes, and terminal display cells. None of this will happen as one big rewrite. We will replace pieces when we understand the problem well enough and when the result is clearly simpler, faster, or more useful. To achieve all of this we might break public interfaces. Thanks to OpenCode and a lot of good models, migration to a new version with breaking changes mostly is not an issue anymore. What do you want to see next for OpenTUI?
0:57

What's next for OpenTUI? Here's a technical write-up. Over the last few months OpenTUI gained a lot of stability improvements, new unnecessary but fun features like live audio streaming, and useful features like rendering to the scrollback buffer mixed with a live TUI, called footer mode. Overall the feature set enables building large and complex applications. React and Solid make it super simple and convenient. There is still so much to do though. Three big milestones we have set out to achieve are: - Moving most of the behavioural logic currently living in TypeScript down to the native Zig core - Node compatibility - Optimizing the hell out of primitives like text rendering The render tree mechanisms are currently only usable from TypeScript. Think of the DOM, but controllable like a scene graph. Elements in the render tree are called renderables. They can expose a render method to draw themselves. All renderables are derived from a BaseRenderable. Renderables and the render tree will become native primitives. Building blocks usable from any language bindings. Reducing the TypeScript bindings to a very thin layer, with all the behavioural logic living in the native binary. Moving this down is not just a matter of porting TypeScript classes to Zig. TypeScript currently owns the tree, dirty-state propagation, layout reads, culling, and render ordering. If it still has to walk every node and call into native code for each step, we keep most of the complexity and add FFI overhead. Whole passes and their state need to move together. We took a big step towards this recently by building yoga-layout into the native binary. It exposes part of the official yoga-layout TypeScript package via FFI. Only the API surface that is actually used by OpenTUI. Covered by the test suite of the original yoga-layout package. This already gave a median speedup of ~2.5x, and up to 30x for narrow scenarios. The yoga-layout integration is useful beyond the speedup. Built-in text and editor measurement can now happen entirely in native code during layout instead of calling back into JavaScript. I ran an experiment last month taking this even further, having GPT 5.6 port yoga-layout from C++ to Zig, which gave extremely good results. It would be a burden to maintain right now though, so that's off the table for now. I might come back to it. Simon Klee is working relentlessly on Node compatibility and already has a full Node version of OpenCode running. Node got FFI support in v26.4.0, thanks to help from the Node community, namely Matteo Collina and Paolo Insogna. Behaviour and interfaces seem similar between Node and Bun, but there are some major differences. To get the best performance out of the Node FFI implementation, its usage has to follow some rules. Node has three ways to call native functions: the generic C++/libffi path, the SharedBuffer path, and the V8 Fast API. The generic path converts every argument in Node's C++ layer and then calls the function through libffi. It is flexible, but also the slowest option for frequently called functions. The SharedBuffer path is a middle ground. JavaScript writes scalar values and BigInt pointers into a small per-function buffer, reducing some conversion work. The actual native call still goes through libffi though. Typed arrays used as pointers cannot be packed into this buffer and fall back to the generic path. The path we really want is the V8 Fast API. Node generates a small machine-code trampoline for the exact function signature, allowing optimized JavaScript to call the native function without going through the generic converter or libffi. This only applies to JavaScript-to-native calls. Callbacks from native code into JavaScript still use libffi closures. Getting onto this path is quite strict. A signature can have at most eight arguments and everything must fit into CPU registers. x86-64 Unix systems have room for six GP (general-purpose) and eight FP (floating-point) arguments. AArch64 has room for seven GP and eight FP arguments. Anything that spills onto the stack falls back to a slower path. These are Node fast-path restrictions, not general FFI restrictions. Bun also does not support passing structs by value through its current FFI API. OpenTUI uses bun-ffi-structs to pack ABI-aligned struct data into an ArrayBuffer and passes a pointer instead. Despite the name, the package also works with Node. Pointers need some care too. Typed arrays and ArrayBuffers normally have to be resolved into BigInt addresses first. Eligible functions with exactly one pointer argument get another Fast API entrypoint that can extract the address directly from the buffer. An eligible signature is still not enough. V8 has to optimize a direct call with a fixed number of consistently typed arguments. Wrappers that collect arguments and forward them using spread or Reflect.apply can hide that call shape and keep the function on a slower path. The practical rules are: keep hot signatures within register limits, use direct fixed-arity calls with stable argument types, reuse owned buffers safely, and batch small operations. Then measure the real call site, because eligibility only makes a function fast-capable. We have to design the ABI around these constraints where it makes sense and gives the expected performance improvement. The third big area is text rendering. Today a Text renderable accepts a string, StyledText, or a tree of TextNodes. Before rendering, the TextNode tree is walked and flattened into styled chunks. Those chunks are packed in TypeScript, sent through FFI, copied into a native TextBuffer, and stored in a rope. Styles are represented separately as highlights. A TextBufferView then wraps the rope into visual lines, which are drawn into the visible buffer. This works, but updates are much more expensive than they should be. setStyledText effectively throws away and rebuilds the rope, copies and reparses all text and recreates the style highlights. Changing one TextNode also walks and flattens the complete tree before going through this path again. Text and style segments should instead live directly in the rope and support incremental replacement. Memory ownership is split between retained JavaScript buffers, the native memory registry, rope arenas, wrapping caches, styled-text storage, and highlights. Different operations preserve or reset different parts of that state. This is hard to reason about and can retain memory for much longer than expected. Text storage needs clearer ownership, with fewer lifetimes split across JavaScript and native code. The public API reflects the same split. The t template literal is convenient, but creates another intermediate chunk representation that is mutable, not cached, and not merged. Text also maintains both StyledText content and a special TextNode tree, which do not compose properly. TextNode is only a style scope, not a normal layout primitive, so Text renderables cannot naturally compose inside each other. I think this should become one Text primitive backed directly by rope segments. The template literal API might disappear or become a very thin helper around those native segments. Editing has another temporary layer in TypeScript. Extmarks currently monkey-patch editing operations, scan and adjust all marks after changes, maintain their own undo state, and recreate native highlights. They should become native marks anchored directly in the rope. A proper mark tree, similar to Neovim's marktree, could update marks together with edits, undo, and redo, and provide the foundation for highlights and concealment. Text wrapping has also become too complex. Supporting CJK, emoji, combining characters, ZWJ sequences, tabs, and different terminal width rules currently mixes byte offsets, grapheme indexes, and display-cell columns across several custom algorithms. Dirty views rewrap the complete document. Measurement and drawing can repeat some of the same work. The wrapping implementation needs an overhaul, but the exact shape is still open. The goal is to make Unicode handling easier to maintain, avoid repeated full-document work, and clearly separate byte offsets, graphemes, and terminal display cells. None of this will happen as one big rewrite. We will replace pieces when we understand the problem well enough and when the result is clearly simpler, faster, or more useful. To achieve all of this we might break public interfaces. Thanks to OpenCode and a lot of good models, migration to a new version with breaking changes mostly is not an issue anymore. What do you want to see next for OpenTUI?

kmdr

29,430 просмотров • 1 месяц назад

Tiny drone hits invisible mode by twisting faster than eye can detect | Omar Kardoudi, New Atlas Engineers at Northwestern University have built a drone that vanishes without camouflage or transparent panels. Its trick is spinning so fast that your eyes simply give up trying to focus, a stealth edge that could turn surveillance into something almost invisible. The aircraft, nicknamed Phantom Twist, rotates up to 25 times per second, a rate that outpaces how quickly our visual system can process sharp detail. Instead of true invisibility, the drone dissolves into a faint, ghostly blur that blends into whatever is behind it. The work, led by associate professor Michael Rubenstein, was presented on July 16 at the Robotics: Science and Systems 2026 conference in Sydney, Australia, under the title Computational Design of a Low-Visibility UAV Using Human-Aligned Perceptual Metric. "Most efforts to hide drones focus on making them look like their surroundings," says Rubenstein. "Instead, we asked whether we could design the drone itself around the way humans perceive motion. This idea of low visibility through persistent motion is something few people have explored." That distinction matters because drones are increasingly used to watch wildlife, check aging infrastructure, or survey wetlands, but their mere presence changes the behavior of whatever they're observing. Birds scatter, animals flee, people act differently. A drone that's hard to spot could do the same job without that side effect. Prior attempts at motion-based concealment offer useful context here. The Northwestern paper points to an earlier project nicknamed the Boomerang Drone, covered in a 2006 New York Times Magazine piece, which tried a similar high-speed rotation trick but couldn't spin fast enough to fully exploit the blur effect, leaving it largely visible. The paper authors also trace the broader idea of active concealment back to the "Yehudi light," a counter-illumination project developed by the National Defense Research Committee in 1944 to hide Allied sea-search aircraft from enemy view. The Phantom Twist itself takes a very different shape from those earlier attempts. Rather than a typical quadcopter with four separate rotors, it runs on a single motor and a single propeller, with the propeller spinning one way while the rest of the drone's body spins the opposite way. "For a typical quadrotor drone, the propellers are spinning, but the robot is stationary," Rubenstein explains. "So, you still see its body. For our drone, the whole thing is rotating, so there are no stationary parts." To reach that layout, the team's computer model generated roughly 20,000 possible drone configurations capable of stable flight, then used artificial intelligence and optimization algorithms to repeatedly rearrange the motor, propeller, circuit board, counterweight, and batteries. Each design was simulated spinning mid-flight and overlaid on 100 real-world backgrounds, then scored by a perceptual model built to mimic human vision, where a lower score meant better camouflage. The 500 best-scoring designs were run through the optimizer again to squeeze out further gains before a final version was built. Emma Alexander, an assistant professor of computer science and one of the study's co-authors, explains the underlying physics. "The human eye takes time to accumulate signals, roughly analogous to the exposure time of a camera," she says. "When an object spins quickly, we perceive it as blurring out and losing distinct features. Because this new drone is almost entirely transparent, its few opaque components are visually averaged with the background for an overall appearance of a slight haze." According to the paper's visibility metric, the finished drone is about 10 times harder to spot than a standard quadcopter. But the spinning trick has real limits that make this drone far from being completely unnoticeable. The propeller still makes an audible whir that gives the drone away even when the eye can't, and its support wires and rods remain partly visible. The paper's authors suggest future versions could lean on more transparent materials and quieter propulsion, edging the drone ever closer to true – and somewhat scary – invisibility. After all, the same trick making a drone less impactful on wildlife could just as easily help it sneak around for reasons that aren't so friendly.
1:11

Tiny drone hits invisible mode by twisting faster than eye can detect | Omar Kardoudi, New Atlas Engineers at Northwestern University have built a drone that vanishes without camouflage or transparent panels. Its trick is spinning so fast that your eyes simply give up trying to focus, a stealth edge that could turn surveillance into something almost invisible. The aircraft, nicknamed Phantom Twist, rotates up to 25 times per second, a rate that outpaces how quickly our visual system can process sharp detail. Instead of true invisibility, the drone dissolves into a faint, ghostly blur that blends into whatever is behind it. The work, led by associate professor Michael Rubenstein, was presented on July 16 at the Robotics: Science and Systems 2026 conference in Sydney, Australia, under the title Computational Design of a Low-Visibility UAV Using Human-Aligned Perceptual Metric. "Most efforts to hide drones focus on making them look like their surroundings," says Rubenstein. "Instead, we asked whether we could design the drone itself around the way humans perceive motion. This idea of low visibility through persistent motion is something few people have explored." That distinction matters because drones are increasingly used to watch wildlife, check aging infrastructure, or survey wetlands, but their mere presence changes the behavior of whatever they're observing. Birds scatter, animals flee, people act differently. A drone that's hard to spot could do the same job without that side effect. Prior attempts at motion-based concealment offer useful context here. The Northwestern paper points to an earlier project nicknamed the Boomerang Drone, covered in a 2006 New York Times Magazine piece, which tried a similar high-speed rotation trick but couldn't spin fast enough to fully exploit the blur effect, leaving it largely visible. The paper authors also trace the broader idea of active concealment back to the "Yehudi light," a counter-illumination project developed by the National Defense Research Committee in 1944 to hide Allied sea-search aircraft from enemy view. The Phantom Twist itself takes a very different shape from those earlier attempts. Rather than a typical quadcopter with four separate rotors, it runs on a single motor and a single propeller, with the propeller spinning one way while the rest of the drone's body spins the opposite way. "For a typical quadrotor drone, the propellers are spinning, but the robot is stationary," Rubenstein explains. "So, you still see its body. For our drone, the whole thing is rotating, so there are no stationary parts." To reach that layout, the team's computer model generated roughly 20,000 possible drone configurations capable of stable flight, then used artificial intelligence and optimization algorithms to repeatedly rearrange the motor, propeller, circuit board, counterweight, and batteries. Each design was simulated spinning mid-flight and overlaid on 100 real-world backgrounds, then scored by a perceptual model built to mimic human vision, where a lower score meant better camouflage. The 500 best-scoring designs were run through the optimizer again to squeeze out further gains before a final version was built. Emma Alexander, an assistant professor of computer science and one of the study's co-authors, explains the underlying physics. "The human eye takes time to accumulate signals, roughly analogous to the exposure time of a camera," she says. "When an object spins quickly, we perceive it as blurring out and losing distinct features. Because this new drone is almost entirely transparent, its few opaque components are visually averaged with the background for an overall appearance of a slight haze." According to the paper's visibility metric, the finished drone is about 10 times harder to spot than a standard quadcopter. But the spinning trick has real limits that make this drone far from being completely unnoticeable. The propeller still makes an audible whir that gives the drone away even when the eye can't, and its support wires and rods remain partly visible. The paper's authors suggest future versions could lean on more transparent materials and quieter propulsion, edging the drone ever closer to true – and somewhat scary – invisibility. After all, the same trick making a drone less impactful on wildlife could just as easily help it sneak around for reasons that aren't so friendly.

Owen Gregorian

24,363 просмотров • 1 месяц назад

$NVDA $GFS NVIDIA’s reported agreement to acquire Groq for $20B in cash (per CNBC, amplified via Reuters and other wire coverage) represents a materially different strategic posture than NVIDIA’s prior M&A pattern, given both the headline size (largest reported NVIDIA acquisition to date) and the unusual carve-out that Groq’s early-stage cloud business would not be included. Public reporting indicates the information originated from Alex Davis, CEO of Disruptive (lead investor in Groq’s latest financing), and that neither NVIDIA nor Groq had issued an immediate confirmation at the time of publication. The same reporting frames the transaction as coming together quickly, only months after Groq raised $750M at a ~$6.9B valuation, and highlights Groq’s positioning as a high-performance inference chip vendor founded by ex-Google TPU engineers. Groq is best understood as a vertically integrated inference acceleration company whose core asset is an application-specific processor optimized for deterministic, low-latency execution of transformer-style workloads, paired with a compiler-led software stack and a distribution layer (GroqCloud) designed to reduce developer friction via OpenAI-compatible APIs and integrations. Groq brands its architecture as a Language Processing Unit (LPU) and consistently emphasizes that the design target is inference, not training. The company’s own architecture description centers on 1-core execution, large on-chip SRAM used as primary storage (explicitly not cache), a custom compiler that statically schedules compute and communication, and direct chip-to-chip connectivity intended to coordinate multi-chip execution without relying on conventional caching hierarchies or dynamic runtime scheduling. The technical premise is a deliberate inversion of the conventional GPU approach. GPUs deliver throughput via massively parallel, multi-core execution with dynamic scheduling, complex memory hierarchies, and heavy reliance on off-chip HBM bandwidth and sophisticated runtime/kernel optimization. Groq instead argues that inference bottlenecks are driven by latency variance (tail latency), synchronization overhead, and memory access unpredictability inherent in dynamically scheduled, cache-heavy architectures, particularly when workloads are latency sensitive and batch sizes cannot be inflated. Groq’s solution is to move “control” into the compiler: the full execution graph and inter-chip communication schedule are computed ahead of time down to clock-cycle granularity, with deterministic execution designed to reduce run-to-run variance. In Groq’s framing, the removal of caches, reorder buffers, speculative execution overhead, and other sources of contention enables predictable latency and high utilization without per-model kernel engineering typical of GPU tuning cycles. A critical nuance is that Groq’s determinism is not merely a software claim; it is tightly coupled to architectural constraints and system design choices that trade flexibility for predictability. Third-party technical commentary indicates Groq’s chip uses a fully deterministic VLIW-style approach with minimal buffering, no external memory, and heavy dependence on sharding models across many chips because on-chip SRAM capacity is limited. SemiAnalysis describes a ~725 mm^2 die on GlobalFoundries 14nm with ~230MB of SRAM and notes that “no useful models” fit on a single chip, forcing multi-chip partitioning for modern LLMs and driving a system-level design where networking and compilation are first-class scheduling problems rather than ancillary infrastructure. This is consistent with Groq’s own messaging that tensor parallelism across chips is a primary design goal, enabled by large on-chip SRAM and compile-time coordination of compute plus interconnect. The on-chip SRAM emphasis is central to Groq’s latency story and also its most constraining trade-off. Groq claims on-chip SRAM bandwidth “upwards of 80 TB/s” and contrasts that with off-chip HBM bandwidth “about 8 TB/s,” asserting a potential 10x advantage from bandwidth plus reduced trips across chip-to-memory boundaries. While these comparisons are marketing-oriented and depend on workload specifics, the architectural implication is clear: Groq prioritizes ultra-fast local weight/activation access and then scales capacity by adding chips, not by attaching large off-chip memory pools. This design can reduce latency for sequential inference layers and minimize unpredictable stalls, but it pushes complexity into partitioning strategy, interconnect topology, and compiler scheduling, and it increases the number of chips needed for very large parameter counts and large KV-cache footprints. Groq also highlights numeric formats and compiler-driven precision management as a performance lever. In its 2025 technical blog, Groq describes “TruePoint numerics,” including 100-bit intermediate accumulation and selective quantization choices (FP32 for attention-sensitive operations, block floating point for MoE weights, FP8 storage in error-tolerant layers), and claims 2-4x speedups versus BF16 without measurable accuracy degradation on benchmarks such as MMLU and HumanEval. Even if the absolute uplift is workload dependent, the strategic point is that Groq is pursuing performance via end-to-end co-design: precision policy is not just hardware capability (FP8/BF16) but compiler-enforced mapping of precision to error sensitivity, which can matter materially for inference cost-per-token if it reduces memory traffic and boosts throughput without forcing aggressive, accuracy-damaging quantization. Independent performance datapoints indicate Groq has been credible on latency-oriented inference speed, at least for certain regimes. EE Times reported in 2023 that Groq demonstrated Llama-2 70B inference at ~240 tokens/s per user on a cloud-based dev system described as 10 racks and 64 chips, using the company’s 1st-gen silicon introduced several years earlier. Separate Groq commentary around independent benchmarking cites results showing ~241 tokens/s throughput and ~0.8s time to receive 100 output tokens for a Llama-2 70B API configuration, positioning the platform as a step-change in “available speed” for certain interactive use cases. These figures do not settle total cost-of-ownership versus GPUs or hyperscaler ASICs, but they establish that Groq’s system-level architecture can deliver strong single-user throughput and latency on large models when properly partitioned and scheduled. GroqCloud is the commercial wrapper that packages this hardware/software stack as “tokens-as-a-service,” aiming to make Groq adoption feel like switching API endpoints rather than adopting new silicon. Groq’s documentation states its API is designed to be “mostly compatible” with OpenAI client libraries, and its pricing page provides model-specific token rates, published speeds (tokens/s), prompt caching discounts, and batch processing discounts. For example, pricing lists inputs as low as $0.05 per 1M tokens and outputs as low as $0.08 per 1M tokens for certain smaller LLM configurations, with higher prices for larger models and long-context or MoE variants; it also advertises prompt caching with a 50% discount on cached input tokens for certain models and a batch API offering 50% lower cost for asynchronous processing windows. These mechanics are economically important because they demonstrate Groq’s go-to-market is not simply “sell chips,” but “sell predictable unit economics per token,” with tooling (batch, caching) that directly targets inference cost drivers (reused prompts, throughput smoothing, and asynchronous workloads). The cloud footprint and distribution partnerships indicate Groq has been building an inference-native “edge within the cloud” strategy rather than competing head-on with hyperscalers on breadth of services. A 2025 Groq newsroom release describes a European deployment in Helsinki with Equinix, positioned as latency reduction and data governance for European customers, and explicitly references Equinix Fabric enabling private connectivity to GroqCloud over public, private, or sovereign infrastructure. The same release enumerates additional capacity in the U.S. (Equinix, DataBank), Canada (Bell Canada), and Saudi Arabia (HUMAIN), and states these sites collectively served more than 20M tokens/s across Groq’s global network at that time. That supply-side metric matters because it provides a directional sense that Groq is scaling capacity as a network, not merely as a chip vendor. Customer disclosure is inherently limited because Groq is private and many enterprise deployments are not public, but Groq’s marketing materials and partnerships provide signals about demand vectors. The company’s public website displays logos of large consumer and enterprise brands (e.g., Dropbox, Vercel, Chevron, Volkswagen, Canva, Robinhood, Riot Games, Workday, Ramp) and includes a published customer quote claiming a 7.41x chat speed increase and an 89% cost reduction after moving to GroqCloud, followed by a tripling of token consumption. While marketing claims should be treated as case-specific and not generalized, they indicate that Groq is targeting both AI-native developers (who measure success by latency and cost-per-token) and enterprise buyers (who care about predictable performance and governance). Supplier and dependency mapping for Groq spans 3 layers: silicon production, system integration, and cloud infrastructure. On silicon, third-party analysis indicates GlobalFoundries 14nm for the 1st-gen Groq chip, implying a supply chain less constrained by the most capacity-tight leading-edge nodes and advanced packaging bottlenecks that dominate high-end GPU supply (HBM stacks, CoWoS-type packaging constraints). If accurate, this is strategically meaningful because it suggests Groq capacity expansion could be gated more by conventional wafer supply, board assembly, and data center power than by the same HBM/advanced packaging scarcity that has constrained top-tier GPU ramp cycles. On systems and cloud, Groq’s own releases identify colocation and connectivity partners (Equinix, DataBank, Bell Canada) and a Middle East partner (HUMAIN), implying dependencies on data center real estate, power availability, and network connectivity, alongside procurement of standard server components, NICs/switching, racks, and cooling infrastructure. The Groq design narrative also emphasizes air cooling and reduced need for complex power/cooling infrastructure, which—if realized in deployments—can widen the set of feasible hosting locations and lower deployment friction relative to liquid-cooled, very high power density GPU racks. Against that backdrop, the strategic rationale for NVIDIA acquiring Groq can be framed as a set of overlapping objectives: inference silicon optionality, architectural hedging, competitive defense, and supply chain diversification, with the carve-out of GroqCloud signaling a preference to avoid direct cloud competition and to focus on IP and product portfolio control rather than operating a capital-intensive token-serving business. The deal, if confirmed, would occur at a valuation step-up of ~190% versus Groq’s reported ~$6.9B private valuation in the September $750M round, reinforcing that any acquisition logic would be predominantly strategic rather than a conventional financial multiple arbitrage. The most compelling strategic driver is inference. Training has historically been the center of gravity for cutting-edge GPU demand, but inference volume is structurally larger and more distributed as deployments scale, with economics dominated by cost-per-token, latency guarantees, and utilization under spiky demand. Inference workloads also create a strategic vulnerability for NVIDIA: hyperscalers and large platforms can justify bespoke ASICs (TPU, Trainium/Inferentia, Maia-class efforts) because inference is stable, repeatable, and can amortize software investment at massive scale. Groq’s core proposition—deterministic, compiler-scheduled inference with predictable latency—aligns directly with the segment where GPU generality is least valued and where “good enough” programmability plus superior unit economics can win share. Acquiring Groq would allow NVIDIA to own a credible inference-native architecture rather than relying solely on GPUs and software optimization to defend that segment. Competitive defense logic is also plausible. Groq occupies a specific competitive wedge: low-latency, high-throughput interactive inference, delivered via a simple API abstraction that reduces switching cost. That wedge directly pressures GPU inference margins in the long run because it makes inference price/performance comparisons more transparent at the token level, and it targets a developer persona that historically defaulted to CUDA-first ecosystems. Even if NVIDIA’s current-generation systems can achieve very high tokens/s per user with extensive optimization, the strategic risk is that competing architectures normalize the idea that inference is best served by special-purpose silicon with a simpler programming model, weakening CUDA lock-in at the application layer. NVIDIA has actively demonstrated that Blackwell-era systems can exceed 1,000 tokens/s per user in benchmarked configurations, but that performance leadership does not automatically translate to lowest cost-per-token across the full range of batch sizes, latency targets, and deployment environments. Groq’s existence as a credible alternative architecture forces NVIDIA to keep defending inference economics rather than only raw performance leadership. The “technology acquisition” rationale is unusually strong in this specific case because Groq’s differentiator is not a single block of silicon IP but an end-to-end methodology: compiler-led static scheduling, deterministic networking, and a system architecture designed around tensor-parallel inference rather than throughput-maximizing batch inference. NVIDIA’s stack is already compiler-heavy (TensorRT, Triton, CUDA graphs, kernel fusion, speculative decoding techniques), but GPUs remain dynamically scheduled devices with complex memory hierarchies and stochastic latency behaviors under contention. Groq’s approach provides an alternate design point: treating the entire inference execution (compute plus communication) as a statically schedulable program. In principle, that IP could be valuable even if Groq silicon itself is not adopted at massive scale, because it can inform how NVIDIA builds future inference-optimized products, compilers, and networking fabrics, especially as distributed inference with large models makes communication a first-order performance determinant. Supply chain diversification is a non-obvious but potentially important driver. If Groq’s mainstream product generation is truly based on a mature process node and avoids HBM, then the scaling constraints look different than those of state-of-the-art GPUs. NVIDIA’s ability to meet incremental demand has been tightly coupled to advanced packaging and HBM supply, and those constraints can remain binding even when wafer supply is available. An inference ASIC architecture that relies primarily on on-chip SRAM and scales by adding chips—while not costless—could reduce dependence on HBM availability and advanced packaging capacity, enabling NVIDIA to ship “inference capacity” in higher absolute volumes or into geographies and customer segments where the highest-end GPUs are economically or logistically difficult to deploy. This could be particularly relevant for latency-sensitive inference deployed in regional colocation footprints rather than centralized hyperscale campuses. The carve-out of GroqCloud, if accurate, is itself a strategic signal about NVIDIA’s priorities. Operating a token-serving cloud at scale is capital intensive, structurally lower margin than silicon IP rents, and creates channel conflict with hyperscalers and CSP partners who are core NVIDIA customers. NVIDIA has generally positioned its cloud offerings through partnerships rather than as a direct hyperscale competitor. Excluding GroqCloud would preserve neutrality with CSPs and avoid inheriting multi-region data residency obligations and partner contracts, while still allowing NVIDIA to acquire Groq’s silicon, compiler technology, and engineering talent. At the same time, excluding GroqCloud would also mean NVIDIA would not automatically acquire the commercial proof-point of Groq’s unit economics or the customer contracts that validate product-market fit at scale, increasing the importance of diligence on whether Groq’s cloud pricing is structurally profitable or partially subsidized by fundraising. There is also a “preemptive acquisition” angle. The reporting identifies recent investors in Groq’s latest round including large financial institutions and strategic/industry players. In that context, Groq represents an asset that could plausibly have been acquired by a competitor (AMD/Intel) or by a hyperscaler seeking to accelerate inference independence. NVIDIA acquiring Groq could be a defensive move to prevent a credible inference-native architecture from being weaponized by a rival with deep distribution. Even if GroqCloud is carved out, controlling the silicon roadmap and compiler IP would meaningfully constrain Groq’s ability to evolve into a standalone competitor, unless the carved-out entity retains long-term rights to the hardware and software stack. However, the strategic case is not one-sided; there are meaningful risks and potential contradictions that would need to be reconciled for the transaction to be value-accretive on a multi-year horizon. 1st, Groq’s architecture appears to rely on scaling out chip count to achieve capacity, which introduces system cost, networking complexity, and physical footprint considerations. The absence of external memory and limited on-chip SRAM implies very large models require substantial chip parallelism, and the economics then depend heavily on chip cost, yield, power efficiency, and interconnect overhead. SemiAnalysis explicitly frames Groq as trading space for time and raises questions about token economics and whether publicly advertised pricing reflects fully loaded costs or market share capture. 2nd, integration risk is non-trivial. Groq’s compiler-led deterministic model is philosophically and practically different from CUDA’s dominant programming and execution model. A poorly executed integration could create internal product confusion, dilute engineering focus, or alienate developers if the combined stack fragments. 3rd, there is cannibalization risk. If Groq-class inference silicon undercuts GPU inference economics, NVIDIA could face internal margin trade-offs, even if the goal is to defend share against hyperscaler ASICs. Cannibalization can still be rational if it prevents larger share loss, but it would require crisp portfolio segmentation and go-to-market discipline. The presence of NVIDIA’s own rapidly improving inference performance complicates the “need” for Groq but does not eliminate the “option value.” NVIDIA has demonstrated benchmark-leading tokens/s per user on Blackwell-based systems, suggesting that raw interactive throughput is not necessarily the limiting factor for NVIDIA’s product line. The more enduring strategic question is unit economics and architectural control: whether future inference demand is better monetized through general-purpose GPUs plus software optimization, or whether a bifurcated product portfolio (training GPUs plus inference-native ASICs) becomes necessary to defend total AI compute wallet share as hyperscaler ASIC penetration increases. Acquiring Groq could be a decisive move to ensure NVIDIA participates in both regimes rather than betting exclusively on GPUs to win inference forever. What is “special” about Groq’s technology relative to a typical accelerator roadmap is the tight coupling of determinism, compilation, and networking into a single scheduling problem. The LPU narrative emphasizes deterministic compute and networking, static scheduling, and direct chip-to-chip coordination that allows “hundreds” (more precisely, 100s) of chips to behave like a single scheduled resource. The architecture also explicitly targets tensor-parallel, latency-optimized distribution rather than pure data-parallel throughput scaling, which matters for real-time applications where a single response must arrive quickly rather than many requests being processed in bulk. The implication is that Groq is optimized for the time-to-first-token and steady token streaming behavior that defines user experience in interactive LLMs, and it attempts to achieve that without relying on large batch sizes that can degrade latency. From a portfolio manager’s perspective, the most important interpretation is that an NVIDIA-Groq combination would likely be less about “NVIDIA needs more inference speed” and more about controlling the architectural trajectory of inference acceleration and removing a fast-improving, developer-friendly competitor from the market. The carve-out of GroqCloud would reinforce that the transaction is aimed at IP, talent, and product optionality, not acquiring a cloud revenue stream. The valuation step-up implied by $20B versus $6.9B would therefore be justified only if the acquired assets materially reduce long-term competitive risk (hyperscaler ASIC displacement, inference margin compression) or enable new monetization vectors (inference ASIC product line, supply chain de-bottlenecking, improved software determinism) that would be difficult to achieve on a comparable timeline via internal R&D.
10:20

$NVDA $GFS NVIDIA’s reported agreement to acquire Groq for $20B in cash (per CNBC, amplified via Reuters and other wire coverage) represents a materially different strategic posture than NVIDIA’s prior M&A pattern, given both the headline size (largest reported NVIDIA acquisition to date) and the unusual carve-out that Groq’s early-stage cloud business would not be included. Public reporting indicates the information originated from Alex Davis, CEO of Disruptive (lead investor in Groq’s latest financing), and that neither NVIDIA nor Groq had issued an immediate confirmation at the time of publication. The same reporting frames the transaction as coming together quickly, only months after Groq raised $750M at a ~$6.9B valuation, and highlights Groq’s positioning as a high-performance inference chip vendor founded by ex-Google TPU engineers. Groq is best understood as a vertically integrated inference acceleration company whose core asset is an application-specific processor optimized for deterministic, low-latency execution of transformer-style workloads, paired with a compiler-led software stack and a distribution layer (GroqCloud) designed to reduce developer friction via OpenAI-compatible APIs and integrations. Groq brands its architecture as a Language Processing Unit (LPU) and consistently emphasizes that the design target is inference, not training. The company’s own architecture description centers on 1-core execution, large on-chip SRAM used as primary storage (explicitly not cache), a custom compiler that statically schedules compute and communication, and direct chip-to-chip connectivity intended to coordinate multi-chip execution without relying on conventional caching hierarchies or dynamic runtime scheduling. The technical premise is a deliberate inversion of the conventional GPU approach. GPUs deliver throughput via massively parallel, multi-core execution with dynamic scheduling, complex memory hierarchies, and heavy reliance on off-chip HBM bandwidth and sophisticated runtime/kernel optimization. Groq instead argues that inference bottlenecks are driven by latency variance (tail latency), synchronization overhead, and memory access unpredictability inherent in dynamically scheduled, cache-heavy architectures, particularly when workloads are latency sensitive and batch sizes cannot be inflated. Groq’s solution is to move “control” into the compiler: the full execution graph and inter-chip communication schedule are computed ahead of time down to clock-cycle granularity, with deterministic execution designed to reduce run-to-run variance. In Groq’s framing, the removal of caches, reorder buffers, speculative execution overhead, and other sources of contention enables predictable latency and high utilization without per-model kernel engineering typical of GPU tuning cycles. A critical nuance is that Groq’s determinism is not merely a software claim; it is tightly coupled to architectural constraints and system design choices that trade flexibility for predictability. Third-party technical commentary indicates Groq’s chip uses a fully deterministic VLIW-style approach with minimal buffering, no external memory, and heavy dependence on sharding models across many chips because on-chip SRAM capacity is limited. SemiAnalysis describes a ~725 mm^2 die on GlobalFoundries 14nm with ~230MB of SRAM and notes that “no useful models” fit on a single chip, forcing multi-chip partitioning for modern LLMs and driving a system-level design where networking and compilation are first-class scheduling problems rather than ancillary infrastructure. This is consistent with Groq’s own messaging that tensor parallelism across chips is a primary design goal, enabled by large on-chip SRAM and compile-time coordination of compute plus interconnect. The on-chip SRAM emphasis is central to Groq’s latency story and also its most constraining trade-off. Groq claims on-chip SRAM bandwidth “upwards of 80 TB/s” and contrasts that with off-chip HBM bandwidth “about 8 TB/s,” asserting a potential 10x advantage from bandwidth plus reduced trips across chip-to-memory boundaries. While these comparisons are marketing-oriented and depend on workload specifics, the architectural implication is clear: Groq prioritizes ultra-fast local weight/activation access and then scales capacity by adding chips, not by attaching large off-chip memory pools. This design can reduce latency for sequential inference layers and minimize unpredictable stalls, but it pushes complexity into partitioning strategy, interconnect topology, and compiler scheduling, and it increases the number of chips needed for very large parameter counts and large KV-cache footprints. Groq also highlights numeric formats and compiler-driven precision management as a performance lever. In its 2025 technical blog, Groq describes “TruePoint numerics,” including 100-bit intermediate accumulation and selective quantization choices (FP32 for attention-sensitive operations, block floating point for MoE weights, FP8 storage in error-tolerant layers), and claims 2-4x speedups versus BF16 without measurable accuracy degradation on benchmarks such as MMLU and HumanEval. Even if the absolute uplift is workload dependent, the strategic point is that Groq is pursuing performance via end-to-end co-design: precision policy is not just hardware capability (FP8/BF16) but compiler-enforced mapping of precision to error sensitivity, which can matter materially for inference cost-per-token if it reduces memory traffic and boosts throughput without forcing aggressive, accuracy-damaging quantization. Independent performance datapoints indicate Groq has been credible on latency-oriented inference speed, at least for certain regimes. EE Times reported in 2023 that Groq demonstrated Llama-2 70B inference at ~240 tokens/s per user on a cloud-based dev system described as 10 racks and 64 chips, using the company’s 1st-gen silicon introduced several years earlier. Separate Groq commentary around independent benchmarking cites results showing ~241 tokens/s throughput and ~0.8s time to receive 100 output tokens for a Llama-2 70B API configuration, positioning the platform as a step-change in “available speed” for certain interactive use cases. These figures do not settle total cost-of-ownership versus GPUs or hyperscaler ASICs, but they establish that Groq’s system-level architecture can deliver strong single-user throughput and latency on large models when properly partitioned and scheduled. GroqCloud is the commercial wrapper that packages this hardware/software stack as “tokens-as-a-service,” aiming to make Groq adoption feel like switching API endpoints rather than adopting new silicon. Groq’s documentation states its API is designed to be “mostly compatible” with OpenAI client libraries, and its pricing page provides model-specific token rates, published speeds (tokens/s), prompt caching discounts, and batch processing discounts. For example, pricing lists inputs as low as $0.05 per 1M tokens and outputs as low as $0.08 per 1M tokens for certain smaller LLM configurations, with higher prices for larger models and long-context or MoE variants; it also advertises prompt caching with a 50% discount on cached input tokens for certain models and a batch API offering 50% lower cost for asynchronous processing windows. These mechanics are economically important because they demonstrate Groq’s go-to-market is not simply “sell chips,” but “sell predictable unit economics per token,” with tooling (batch, caching) that directly targets inference cost drivers (reused prompts, throughput smoothing, and asynchronous workloads). The cloud footprint and distribution partnerships indicate Groq has been building an inference-native “edge within the cloud” strategy rather than competing head-on with hyperscalers on breadth of services. A 2025 Groq newsroom release describes a European deployment in Helsinki with Equinix, positioned as latency reduction and data governance for European customers, and explicitly references Equinix Fabric enabling private connectivity to GroqCloud over public, private, or sovereign infrastructure. The same release enumerates additional capacity in the U.S. (Equinix, DataBank), Canada (Bell Canada), and Saudi Arabia (HUMAIN), and states these sites collectively served more than 20M tokens/s across Groq’s global network at that time. That supply-side metric matters because it provides a directional sense that Groq is scaling capacity as a network, not merely as a chip vendor. Customer disclosure is inherently limited because Groq is private and many enterprise deployments are not public, but Groq’s marketing materials and partnerships provide signals about demand vectors. The company’s public website displays logos of large consumer and enterprise brands (e.g., Dropbox, Vercel, Chevron, Volkswagen, Canva, Robinhood, Riot Games, Workday, Ramp) and includes a published customer quote claiming a 7.41x chat speed increase and an 89% cost reduction after moving to GroqCloud, followed by a tripling of token consumption. While marketing claims should be treated as case-specific and not generalized, they indicate that Groq is targeting both AI-native developers (who measure success by latency and cost-per-token) and enterprise buyers (who care about predictable performance and governance). Supplier and dependency mapping for Groq spans 3 layers: silicon production, system integration, and cloud infrastructure. On silicon, third-party analysis indicates GlobalFoundries 14nm for the 1st-gen Groq chip, implying a supply chain less constrained by the most capacity-tight leading-edge nodes and advanced packaging bottlenecks that dominate high-end GPU supply (HBM stacks, CoWoS-type packaging constraints). If accurate, this is strategically meaningful because it suggests Groq capacity expansion could be gated more by conventional wafer supply, board assembly, and data center power than by the same HBM/advanced packaging scarcity that has constrained top-tier GPU ramp cycles. On systems and cloud, Groq’s own releases identify colocation and connectivity partners (Equinix, DataBank, Bell Canada) and a Middle East partner (HUMAIN), implying dependencies on data center real estate, power availability, and network connectivity, alongside procurement of standard server components, NICs/switching, racks, and cooling infrastructure. The Groq design narrative also emphasizes air cooling and reduced need for complex power/cooling infrastructure, which—if realized in deployments—can widen the set of feasible hosting locations and lower deployment friction relative to liquid-cooled, very high power density GPU racks. Against that backdrop, the strategic rationale for NVIDIA acquiring Groq can be framed as a set of overlapping objectives: inference silicon optionality, architectural hedging, competitive defense, and supply chain diversification, with the carve-out of GroqCloud signaling a preference to avoid direct cloud competition and to focus on IP and product portfolio control rather than operating a capital-intensive token-serving business. The deal, if confirmed, would occur at a valuation step-up of ~190% versus Groq’s reported ~$6.9B private valuation in the September $750M round, reinforcing that any acquisition logic would be predominantly strategic rather than a conventional financial multiple arbitrage. The most compelling strategic driver is inference. Training has historically been the center of gravity for cutting-edge GPU demand, but inference volume is structurally larger and more distributed as deployments scale, with economics dominated by cost-per-token, latency guarantees, and utilization under spiky demand. Inference workloads also create a strategic vulnerability for NVIDIA: hyperscalers and large platforms can justify bespoke ASICs (TPU, Trainium/Inferentia, Maia-class efforts) because inference is stable, repeatable, and can amortize software investment at massive scale. Groq’s core proposition—deterministic, compiler-scheduled inference with predictable latency—aligns directly with the segment where GPU generality is least valued and where “good enough” programmability plus superior unit economics can win share. Acquiring Groq would allow NVIDIA to own a credible inference-native architecture rather than relying solely on GPUs and software optimization to defend that segment. Competitive defense logic is also plausible. Groq occupies a specific competitive wedge: low-latency, high-throughput interactive inference, delivered via a simple API abstraction that reduces switching cost. That wedge directly pressures GPU inference margins in the long run because it makes inference price/performance comparisons more transparent at the token level, and it targets a developer persona that historically defaulted to CUDA-first ecosystems. Even if NVIDIA’s current-generation systems can achieve very high tokens/s per user with extensive optimization, the strategic risk is that competing architectures normalize the idea that inference is best served by special-purpose silicon with a simpler programming model, weakening CUDA lock-in at the application layer. NVIDIA has actively demonstrated that Blackwell-era systems can exceed 1,000 tokens/s per user in benchmarked configurations, but that performance leadership does not automatically translate to lowest cost-per-token across the full range of batch sizes, latency targets, and deployment environments. Groq’s existence as a credible alternative architecture forces NVIDIA to keep defending inference economics rather than only raw performance leadership. The “technology acquisition” rationale is unusually strong in this specific case because Groq’s differentiator is not a single block of silicon IP but an end-to-end methodology: compiler-led static scheduling, deterministic networking, and a system architecture designed around tensor-parallel inference rather than throughput-maximizing batch inference. NVIDIA’s stack is already compiler-heavy (TensorRT, Triton, CUDA graphs, kernel fusion, speculative decoding techniques), but GPUs remain dynamically scheduled devices with complex memory hierarchies and stochastic latency behaviors under contention. Groq’s approach provides an alternate design point: treating the entire inference execution (compute plus communication) as a statically schedulable program. In principle, that IP could be valuable even if Groq silicon itself is not adopted at massive scale, because it can inform how NVIDIA builds future inference-optimized products, compilers, and networking fabrics, especially as distributed inference with large models makes communication a first-order performance determinant. Supply chain diversification is a non-obvious but potentially important driver. If Groq’s mainstream product generation is truly based on a mature process node and avoids HBM, then the scaling constraints look different than those of state-of-the-art GPUs. NVIDIA’s ability to meet incremental demand has been tightly coupled to advanced packaging and HBM supply, and those constraints can remain binding even when wafer supply is available. An inference ASIC architecture that relies primarily on on-chip SRAM and scales by adding chips—while not costless—could reduce dependence on HBM availability and advanced packaging capacity, enabling NVIDIA to ship “inference capacity” in higher absolute volumes or into geographies and customer segments where the highest-end GPUs are economically or logistically difficult to deploy. This could be particularly relevant for latency-sensitive inference deployed in regional colocation footprints rather than centralized hyperscale campuses. The carve-out of GroqCloud, if accurate, is itself a strategic signal about NVIDIA’s priorities. Operating a token-serving cloud at scale is capital intensive, structurally lower margin than silicon IP rents, and creates channel conflict with hyperscalers and CSP partners who are core NVIDIA customers. NVIDIA has generally positioned its cloud offerings through partnerships rather than as a direct hyperscale competitor. Excluding GroqCloud would preserve neutrality with CSPs and avoid inheriting multi-region data residency obligations and partner contracts, while still allowing NVIDIA to acquire Groq’s silicon, compiler technology, and engineering talent. At the same time, excluding GroqCloud would also mean NVIDIA would not automatically acquire the commercial proof-point of Groq’s unit economics or the customer contracts that validate product-market fit at scale, increasing the importance of diligence on whether Groq’s cloud pricing is structurally profitable or partially subsidized by fundraising. There is also a “preemptive acquisition” angle. The reporting identifies recent investors in Groq’s latest round including large financial institutions and strategic/industry players. In that context, Groq represents an asset that could plausibly have been acquired by a competitor (AMD/Intel) or by a hyperscaler seeking to accelerate inference independence. NVIDIA acquiring Groq could be a defensive move to prevent a credible inference-native architecture from being weaponized by a rival with deep distribution. Even if GroqCloud is carved out, controlling the silicon roadmap and compiler IP would meaningfully constrain Groq’s ability to evolve into a standalone competitor, unless the carved-out entity retains long-term rights to the hardware and software stack. However, the strategic case is not one-sided; there are meaningful risks and potential contradictions that would need to be reconciled for the transaction to be value-accretive on a multi-year horizon. 1st, Groq’s architecture appears to rely on scaling out chip count to achieve capacity, which introduces system cost, networking complexity, and physical footprint considerations. The absence of external memory and limited on-chip SRAM implies very large models require substantial chip parallelism, and the economics then depend heavily on chip cost, yield, power efficiency, and interconnect overhead. SemiAnalysis explicitly frames Groq as trading space for time and raises questions about token economics and whether publicly advertised pricing reflects fully loaded costs or market share capture. 2nd, integration risk is non-trivial. Groq’s compiler-led deterministic model is philosophically and practically different from CUDA’s dominant programming and execution model. A poorly executed integration could create internal product confusion, dilute engineering focus, or alienate developers if the combined stack fragments. 3rd, there is cannibalization risk. If Groq-class inference silicon undercuts GPU inference economics, NVIDIA could face internal margin trade-offs, even if the goal is to defend share against hyperscaler ASICs. Cannibalization can still be rational if it prevents larger share loss, but it would require crisp portfolio segmentation and go-to-market discipline. The presence of NVIDIA’s own rapidly improving inference performance complicates the “need” for Groq but does not eliminate the “option value.” NVIDIA has demonstrated benchmark-leading tokens/s per user on Blackwell-based systems, suggesting that raw interactive throughput is not necessarily the limiting factor for NVIDIA’s product line. The more enduring strategic question is unit economics and architectural control: whether future inference demand is better monetized through general-purpose GPUs plus software optimization, or whether a bifurcated product portfolio (training GPUs plus inference-native ASICs) becomes necessary to defend total AI compute wallet share as hyperscaler ASIC penetration increases. Acquiring Groq could be a decisive move to ensure NVIDIA participates in both regimes rather than betting exclusively on GPUs to win inference forever. What is “special” about Groq’s technology relative to a typical accelerator roadmap is the tight coupling of determinism, compilation, and networking into a single scheduling problem. The LPU narrative emphasizes deterministic compute and networking, static scheduling, and direct chip-to-chip coordination that allows “hundreds” (more precisely, 100s) of chips to behave like a single scheduled resource. The architecture also explicitly targets tensor-parallel, latency-optimized distribution rather than pure data-parallel throughput scaling, which matters for real-time applications where a single response must arrive quickly rather than many requests being processed in bulk. The implication is that Groq is optimized for the time-to-first-token and steady token streaming behavior that defines user experience in interactive LLMs, and it attempts to achieve that without relying on large batch sizes that can degrade latency. From a portfolio manager’s perspective, the most important interpretation is that an NVIDIA-Groq combination would likely be less about “NVIDIA needs more inference speed” and more about controlling the architectural trajectory of inference acceleration and removing a fast-improving, developer-friendly competitor from the market. The carve-out of GroqCloud would reinforce that the transaction is aimed at IP, talent, and product optionality, not acquiring a cloud revenue stream. The valuation step-up implied by $20B versus $6.9B would therefore be justified only if the acquired assets materially reduce long-term competitive risk (hyperscaler ASIC displacement, inference margin compression) or enable new monetization vectors (inference ASIC product line, supply chain de-bottlenecking, improved software determinism) that would be difficult to achieve on a comparable timeline via internal R&D.

TheValueist

102,145 просмотров • 8 месяцев назад