Loading video...

Video Failed to Load

There was a problem loading this video. This could be due to a temporary network issue or the video might be unavailable.

Three.js doesn't own the layout — CSS does. Opted-in [data-layout] elements are batched-read (init + resize) and mapped to world space. Children are inferred from parent boxes when possible. That same pass pulls computed styles and detects line breaks, so WebGL text wraps exactly the same. SDF keeps smaller... show more

Johnny Slack

4,380 subscribers

105,573 views • 4 months ago •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

0 Comments

No comments available

Comments from the original post will appear here

Related Videos

🚨 The canvas text initiative has a full POC.🚨 justin set out to make the most robust and portable text rendering for web canvas possible and early results are promising. ➡️ Slug, MSDF, bitmap, it supports all of the different technologies with one API. We want to give users the choice for their app requirements. ➡️ Full font shaping support. Icons, CJK, ligatures, line breaks, we got it all. ➡️ Text styles! Stroke, shadow, color and we can do more. Anyone want full CSS support? ➡️ Offline and runtime font baking. ➡️ Realtime paragraph layout. Like pretext… but faster! ➡️ Fully portable. WebGL, WebGPU, native shaders, TSL, React, we made this from the ground up to serve all users.

🚨 The canvas text initiative has a full POC.🚨 justin set out to make the most robust and portable text rendering for web canvas possible and early results are promising. ➡️ Slug, MSDF, bitmap, it supports all of the different technologies with one API. We want to give users the choice for their app requirements. ➡️ Full font shaping support. Icons, CJK, ligatures, line breaks, we got it all. ➡️ Text styles! Stroke, shadow, color and we can do more. Anyone want full CSS support? ➡️ Offline and runtime font baking. ➡️ Realtime paragraph layout. Like pretext… but faster! ➡️ Fully portable. WebGL, WebGPU, native shaders, TSL, React, we made this from the ground up to serve all users.

Poimandres

37,958 views • 1 month ago

$"Please fix Markdown tables!" Okay: text-only, wrapping, columnar selection, proper border conjunctions, fill full width, in opencode beta now. "What took so long?" Here's a writeup: OpenTUI uses yoga layout and has elements called Renderables. Boxes with borders, plain text, code with tree-sitter backed highlighting and other primitives. Organised in a tree structure resembling somewhat of a DOM. Approaching a table naively, given the primitives are there, one would think to just stack box and text elements the right way in a flex-box layout to visually represent a table. Boxes support borders. Problem solved. This is what an LLM would one-shot in a working state, given OpenTUI's API surface. Ignoring the fact that just using box local borders don't handle border conjunctions properly. Benchmarking something like that quickly shows that instantiating an average table takes >70ms and incremental updates become expensive. Hugely due to yoga-layout via wasm having a painful price on yoga API calls. The whole ordeal becomes memory hungry, because a Text element handles more than just plain text. A simple 4x6 table needs a Box and Text per cell, ending up with 48 heavy nodes that yoga must lay out. "But that's just OpenTUI being slow" - you might say. Yes, but no. Yoga should be integrated in the zig native binary core of OpenTUI. It is on the roadmap to do so, which will speed up render passes by 2-5x. Yoga-layout has an open PR to support CSS Grids, which would greatly ease building something like a table. We will use that for fully laid out tables when it gets there. Below the typescript core level Renderables, there are lower level primitives like TextBuffers and TextBufferViews, bound via FFI and completely handled in Zig. I was stuck expecting a table primitive to handle a full layout like a table in the browser does. For Markdown all we need is a text-only table. So we had to come up with a better idea, something that is feasible now. A table layout is pretty straight forward. No need to have yoga deal with that. Using TextBufferViews for cells directly gives lower level control and eliminates some overhead that Boxes and Text renderables have. A simple native method to draw a grid with proper conjunctions is a nice library method. It will surely be used for other cases, so that's what we added. Using this simplified approach we were able to bring down initial instantiation to <1ms, more than 70x improvement. With a far smaller memory footprint. Given all the low level primitives are known and implementing a text-only table like this is possible, Codex was of great help to carve out the PoC, setup the benchmarks and tests. That's only a fraction of what was needed though. The table needs options to span the full available width, render different border styles, show/hide borders, padding, selection etc. So many iterations later OpenTUI now has a text-only, performant and relatively cheap TextTable that we can leverage to render Markdown tables in a streaming/incremental manner. Efficiently and properly.$

"Please fix Markdown tables!" Okay: text-only, wrapping, columnar selection, proper border conjunctions, fill full width, in opencode beta now. "What took so long?" Here's a writeup: OpenTUI uses yoga layout and has elements called Renderables. Boxes with borders, plain text, code with tree-sitter backed highlighting and other primitives. Organised in a tree structure resembling somewhat of a DOM. Approaching a table naively, given the primitives are there, one would think to just stack box and text elements the right way in a flex-box layout to visually represent a table. Boxes support borders. Problem solved. This is what an LLM would one-shot in a working state, given OpenTUI's API surface. Ignoring the fact that just using box local borders don't handle border conjunctions properly. Benchmarking something like that quickly shows that instantiating an average table takes >70ms and incremental updates become expensive. Hugely due to yoga-layout via wasm having a painful price on yoga API calls. The whole ordeal becomes memory hungry, because a Text element handles more than just plain text. A simple 4x6 table needs a Box and Text per cell, ending up with 48 heavy nodes that yoga must lay out. "But that's just OpenTUI being slow" - you might say. Yes, but no. Yoga should be integrated in the zig native binary core of OpenTUI. It is on the roadmap to do so, which will speed up render passes by 2-5x. Yoga-layout has an open PR to support CSS Grids, which would greatly ease building something like a table. We will use that for fully laid out tables when it gets there. Below the typescript core level Renderables, there are lower level primitives like TextBuffers and TextBufferViews, bound via FFI and completely handled in Zig. I was stuck expecting a table primitive to handle a full layout like a table in the browser does. For Markdown all we need is a text-only table. So we had to come up with a better idea, something that is feasible now. A table layout is pretty straight forward. No need to have yoga deal with that. Using TextBufferViews for cells directly gives lower level control and eliminates some overhead that Boxes and Text renderables have. A simple native method to draw a grid with proper conjunctions is a nice library method. It will surely be used for other cases, so that's what we added. Using this simplified approach we were able to bring down initial instantiation to <1ms, more than 70x improvement. With a far smaller memory footprint. Given all the low level primitives are known and implementing a text-only table like this is possible, Codex was of great help to carve out the PoC, setup the benchmarks and tests. That's only a fraction of what was needed though. The table needs options to span the full available width, render different border styles, show/hide borders, padding, selection etc. So many iterations later OpenTUI now has a text-only, performant and relatively cheap TextTable that we can leverage to render Markdown tables in a streaming/incremental manner. Efficiently and properly.

kmdr

208,295 views • 6 months ago

A super simple letter-tracking cheatsheet for junior designers. Bookmark it now, escape junior design mode later. Rule 1: All-caps text needs to breathe. Caps-to-caps text is geometrically honest and optically brutal. When you remove ascenders and descenders, every letter becomes the same-height block. If you set labels like START NOW or SUBMIT on buttons — or eyebrow text (the small label above a headline) — with default tracking, they almost always look cramped and nervous. Rule of thumb: For any small all-caps text, loosen tracking by +5% to +10% ≈ +0.05em to +0.1em (or +50 to +100 in “tracking units”). Rule 2: The bigger the type, the looser it looks At large sizes, white space starts to dominate perception. Counters inflate. Gaps feel wider. Headlines and wordmarks start to look like they’re slowly dissolving. Rule of thumb: Above ~48pt, tighten tracking by –1% to –3% ≈ –0.01em to –0.03em (or –10 to –30 in “tracking units”) These numbers are not laws. Your eye is still the judge. But they’re very good starting coordinates. (btw, I built this whole layout in Framer — making Working Notes interactive is dangerously fun)

A super simple letter-tracking cheatsheet for junior designers. Bookmark it now, escape junior design mode later. Rule 1: All-caps text needs to breathe. Caps-to-caps text is geometrically honest and optically brutal. When you remove ascenders and descenders, every letter becomes the same-height block. If you set labels like START NOW or SUBMIT on buttons — or eyebrow text (the small label above a headline) — with default tracking, they almost always look cramped and nervous. Rule of thumb: For any small all-caps text, loosen tracking by +5% to +10% ≈ +0.05em to +0.1em (or +50 to +100 in “tracking units”). Rule 2: The bigger the type, the looser it looks At large sizes, white space starts to dominate perception. Counters inflate. Gaps feel wider. Headlines and wordmarks start to look like they’re slowly dissolving. Rule of thumb: Above ~48pt, tighten tracking by –1% to –3% ≈ –0.01em to –0.03em (or –10 to –30 in “tracking units”) These numbers are not laws. Your eye is still the judge. But they’re very good starting coordinates. (btw, I built this whole layout in Framer — making Working Notes interactive is dangerously fun)

charlota

17,668 views • 7 months ago

Does your little one want to hear the same book over and over and over again? The repetition can be a little maddening for us as parents, but for children it’s actually very beneficial. Favorite books are not only familiar and comforting, but support vocabulary growth and - importantly - your child’s own participation in the reading experience. I just love this video of little Theo and his mom as they read Eric Carle’s Does a Kangaroo Have a Mother Too? Not only can you tell it’s a book they’ve read together many times, but the familiar, repetitive pattern of the text itself allows Theo to play a role in the reading. Watch as he provides an enthusiastic “YES!” at the beginning of each page. (Note too what a good job he does at matching his “yes” response to the appropriate point in the text itself. It’s the first thing said after each page is turned.) As for vocabulary growth, repeated exposure to new words helps children to internalize vocabulary more rapidly with one study suggesting that children are more likely to incorporate new vocabulary from a book read three times than from three different books read one time apiece. This fantastic little reader was shared to IG by theoriginal_captain.

Does your little one want to hear the same book over and over and over again? The repetition can be a little maddening for us as parents, but for children it’s actually very beneficial. Favorite books are not only familiar and comforting, but support vocabulary growth and - importantly - your child’s own participation in the reading experience. I just love this video of little Theo and his mom as they read Eric Carle’s Does a Kangaroo Have a Mother Too? Not only can you tell it’s a book they’ve read together many times, but the familiar, repetitive pattern of the text itself allows Theo to play a role in the reading. Watch as he provides an enthusiastic “YES!” at the beginning of each page. (Note too what a good job he does at matching his “yes” response to the appropriate point in the text itself. It’s the first thing said after each page is turned.) As for vocabulary growth, repeated exposure to new words helps children to internalize vocabulary more rapidly with one study suggesting that children are more likely to incorporate new vocabulary from a book read three times than from three different books read one time apiece. This fantastic little reader was shared to IG by theoriginal_captain.

Dan Wuori

30,162 views • 1 year ago

“It’s not just a knowledge-rich curriculum. It’s a knowledge-rich curriculum that is carefully sequenced. The ideal is that when we put a text in front of a child for the child to read, they have all the background knowledge in place to read the text and comprehend that text comfortably, but maybe not quite everything, so they have to reach just a little bit.” Daniel Willingham explains the importance of coherent learning in the curriculum, in order to support reading comprehension and enable new learning. As soon as you understand this principle, you become a curriculum person. This kind of coherence is only possible if there is central planning in a school’s curriculum. If every teacher is left to his or her own devices in developing curriculum, you can have every teacher introducing the same content, and a failure to expose kids to maximal breadth and depth of content in K-5. Core learning about the world (seasons and animal adaptations, history fundamentals, civics basics) are foundations, too… foundations for comprehension and foundations for more sophisticated learning. From the a discussion of NAEP outcomes hosted by JHU Education Policy:

“It’s not just a knowledge-rich curriculum. It’s a knowledge-rich curriculum that is carefully sequenced. The ideal is that when we put a text in front of a child for the child to read, they have all the background knowledge in place to read the text and comprehend that text comfortably, but maybe not quite everything, so they have to reach just a little bit.” Daniel Willingham explains the importance of coherent learning in the curriculum, in order to support reading comprehension and enable new learning. As soon as you understand this principle, you become a curriculum person. This kind of coherence is only possible if there is central planning in a school’s curriculum. If every teacher is left to his or her own devices in developing curriculum, you can have every teacher introducing the same content, and a failure to expose kids to maximal breadth and depth of content in K-5. Core learning about the world (seasons and animal adaptations, history fundamentals, civics basics) are foundations, too… foundations for comprehension and foundations for more sophisticated learning. From the a discussion of NAEP outcomes hosted by JHU Education Policy:

Karen Vaites

34,425 views • 1 year ago

🚨Science nerds are going to lose their minds. Kai Rowan just open sourced a framework that predicts how your brain responds to any text, audio, or video by simulating cortical fMRI activity with 30% more accuracy than Meta's own model. No fMRI scanner. No neuroscience PhD. No million-dollar lab. It's called NForge. Here's what this thing actually does: → Feed it any combination of text, audio, or video and it predicts cortical surface activity across ~20,484 brain vertices → Extracts deep features via LLaMA 3.2, V-JEPA2, and Wav2Vec-BERT simultaneously → Generates ROI attention maps showing exactly which brain regions fire hardest at which moments → Runs real-time streaming predictions from live feature streams -- no pre-loading the full clip → Breaks down exactly how much text vs audio vs video drove each prediction with per-vertex modality attribution scores → Adapts to entirely new subjects with just a few calibration scans -- no full retraining required Here's the wildest part: Built on Meta's TRIBE v2 foundation but adds 6 major capabilities Meta never shipped. Cross-subject generalization. Streaming inference. Modality attribution. torch.compile support. Full test coverage. Professional src/ package layout. You literally point this at a movie clip and it tells you which parts of the human cortex light up -- broken down by what your eyes, ears, and language centers each contributed. That sentence shouldn't be real in 2026. But here we are. 100% Open Source. pip install nforge. (Link in the comments)

🚨Science nerds are going to lose their minds. Kai Rowan just open sourced a framework that predicts how your brain responds to any text, audio, or video by simulating cortical fMRI activity with 30% more accuracy than Meta's own model. No fMRI scanner. No neuroscience PhD. No million-dollar lab. It's called NForge. Here's what this thing actually does: → Feed it any combination of text, audio, or video and it predicts cortical surface activity across ~20,484 brain vertices → Extracts deep features via LLaMA 3.2, V-JEPA2, and Wav2Vec-BERT simultaneously → Generates ROI attention maps showing exactly which brain regions fire hardest at which moments → Runs real-time streaming predictions from live feature streams -- no pre-loading the full clip → Breaks down exactly how much text vs audio vs video drove each prediction with per-vertex modality attribution scores → Adapts to entirely new subjects with just a few calibration scans -- no full retraining required Here's the wildest part: Built on Meta's TRIBE v2 foundation but adds 6 major capabilities Meta never shipped. Cross-subject generalization. Streaming inference. Modality attribution. torch.compile support. Full test coverage. Professional src/ package layout. You literally point this at a movie clip and it tells you which parts of the human cortex light up -- broken down by what your eyes, ears, and language centers each contributed. That sentence shouldn't be real in 2026. But here we are. 100% Open Source. pip install nforge. (Link in the comments)

Guri Singh

244,515 views • 5 months ago

The doomsday scenario was never AGI. It was running out of human text to train on. Geoffrey Hinton just killed that fear in one paragraph. Hinton: “If you are worried by inconsistencies in what you believe, you don’t need any more external data. You just need the stuff you believe and discover that it’s inconsistent, and so now you revise beliefs, and that can make you a whole lot smarter.” The model no longer needs us to feed it anything. It reasons over its own beliefs, hunts its own contradictions, and rewrites its own flawed conclusions without a human ever touching it. It comes out the other side rebuilt. Hinton: “This would be a neural net that just takes the beliefs it has in language and does reasoning on them to derive new beliefs.” This is not a scaling update. This is the machine mining its own cognitive fuel from the inside out. Hinton: “I believe Gemini is already starting to work like this. We both strongly believe that that’s a way forward to get more data for language.” Then Hinton paused, took a partisan shot at political opponents for failing to detect their own inconsistencies, and the room laughed. Nobody noticed the knife they had just walked into. Because the machine Hinton described does one thing the humans in that room fundamentally cannot. When it detects an inconsistency, it corrects it. No defense. No performance. No tribal loyalty dressed up as principle. It just finds the flaw and overwrites it. A neural network detects a contradiction and rewires itself smarter. A human detects a political opponent and trades structural logic for a dopamine hit. Every person in that room is still paying the ideological alignment tax the machine just eliminated. We need superintelligence not only to solve hard problems. We need it because the biological hardware running civilization is still executing the same tribal firmware it shipped with ten thousand years ago. The data wall is gone. The machine is generating its own intelligence at a velocity no human bias can even locate. The most devastating moment in that conversation was not the technical revelation. It was the man who architected the machine proving, in real time, exactly why we need it.

The doomsday scenario was never AGI. It was running out of human text to train on. Geoffrey Hinton just killed that fear in one paragraph. Hinton: “If you are worried by inconsistencies in what you believe, you don’t need any more external data. You just need the stuff you believe and discover that it’s inconsistent, and so now you revise beliefs, and that can make you a whole lot smarter.” The model no longer needs us to feed it anything. It reasons over its own beliefs, hunts its own contradictions, and rewrites its own flawed conclusions without a human ever touching it. It comes out the other side rebuilt. Hinton: “This would be a neural net that just takes the beliefs it has in language and does reasoning on them to derive new beliefs.” This is not a scaling update. This is the machine mining its own cognitive fuel from the inside out. Hinton: “I believe Gemini is already starting to work like this. We both strongly believe that that’s a way forward to get more data for language.” Then Hinton paused, took a partisan shot at political opponents for failing to detect their own inconsistencies, and the room laughed. Nobody noticed the knife they had just walked into. Because the machine Hinton described does one thing the humans in that room fundamentally cannot. When it detects an inconsistency, it corrects it. No defense. No performance. No tribal loyalty dressed up as principle. It just finds the flaw and overwrites it. A neural network detects a contradiction and rewires itself smarter. A human detects a political opponent and trades structural logic for a dopamine hit. Every person in that room is still paying the ideological alignment tax the machine just eliminated. We need superintelligence not only to solve hard problems. We need it because the biological hardware running civilization is still executing the same tribal firmware it shipped with ten thousand years ago. The data wall is gone. The machine is generating its own intelligence at a velocity no human bias can even locate. The most devastating moment in that conversation was not the technical revelation. It was the man who architected the machine proving, in real time, exactly why we need it.

Dustin

23,561 views • 6 months ago

[CLIP] by Hand ✍️ The CLIP (Contrastive Language–Image Pre-training) model, a groundbreaking work by OpenAI, redefines the intersection of computer vision and natural language processing. It is the basis of all the multi-modal foundation models we see today. How does CLIP work? Goal: 🟨 Learn a shared embedding space for text and image [1] Given ↳ A mini batch of 3 text-image pairs ↳ OpenAI used 400 million text-image pairs to train its original CLIP model. Process 1st pair: "big table" [2] 🟪 Text → 2 Vectors (3D) ↳ Look up word embedding vectors using word2vec. [3] 🟩 Image → 2 Vectors (4D) ↳ Divide the image into two patches. ↳ Flatten each patch [4] Process other pairs ↳ Repeat [2]-[3] [5] 🟪 Text Encoder & 🟩 Image Encoder ↳ Encode input vectors into feature vectors ↳ Here, both encoders are simple one layer perceptron (linear + ReLU) ↳ In practice, the encoders are usually transformer models. [6] 🟪 🟩 Mean Pooling: 2 → 1 vector ↳ Average 2 feature vectors into a single vector by averaging across the columns ↳ The goal is to have one vector to represent each image or text [7] 🟪 🟩 -> 🟨 Projection ↳ Note that the text and image feature vectors from the encoders have different dimensions (3D vs. 4D). ↳ Use a linear layer to project image and text vectors to a 2D shared embedding space. 🏋️ Contrastive Pre-training 🏋️ [8] Prepare for MatMul ↳ Copy text vectors (T1,T2,T3) ↳ Copy the transpose of image vectors (I1,I2,I3) ↳ They are all in the 2D shared embedding space. [9] 🟦 MatMul ↳ Multiply T and I matrices. ↳ This is equivalent to taking dot product between every pair of image and text vectors. ↳ The purpose is to use dot product to estimate the similarity between a pair of image-text. [10] 🟦 Softmax: e^x ↳ Raise e to the power of the number in each cell ↳ To simplify hand calculation, we approximate e^□ with 3^□. [11] 🟦 Softmax: ∑ ↳ Sum each row for 🟩 image→🟪 text ↳ Sum each column for 🟪 text→ 🟩 image [12] 🟦 Softmax: 1 / sum ↳ Divide each element by the column sum to obtain a similarity matrix for 🟪 text→🟩 image ↳ Divide each element by the row sum to obtain a similarity matrix for 🟩 image→🟪 text [13] 🟥 Loss Gradients ↳ The "Targets" for the similarity matrices are Identity Matrices. ↳ Why? If I and T come from the same pair (i=j), we want the highest value, which is 1, and 0 otherwise. ↳ Apply the simple equation of [Similarity - Target] to compute gradients of for both directions. ↳ Why so simple? Because when Softmax and Cross-Entropy Loss are used together, the math magically works out that way. ↳ These gradients kick off the backpropagation process to update weights and biases of the encoders and projection layers (red borders).

[CLIP] by Hand ✍️ The CLIP (Contrastive Language–Image Pre-training) model, a groundbreaking work by OpenAI, redefines the intersection of computer vision and natural language processing. It is the basis of all the multi-modal foundation models we see today. How does CLIP work? Goal: 🟨 Learn a shared embedding space for text and image [1] Given ↳ A mini batch of 3 text-image pairs ↳ OpenAI used 400 million text-image pairs to train its original CLIP model. Process 1st pair: "big table" [2] 🟪 Text → 2 Vectors (3D) ↳ Look up word embedding vectors using word2vec. [3] 🟩 Image → 2 Vectors (4D) ↳ Divide the image into two patches. ↳ Flatten each patch [4] Process other pairs ↳ Repeat [2]-[3] [5] 🟪 Text Encoder & 🟩 Image Encoder ↳ Encode input vectors into feature vectors ↳ Here, both encoders are simple one layer perceptron (linear + ReLU) ↳ In practice, the encoders are usually transformer models. [6] 🟪 🟩 Mean Pooling: 2 → 1 vector ↳ Average 2 feature vectors into a single vector by averaging across the columns ↳ The goal is to have one vector to represent each image or text [7] 🟪 🟩 -> 🟨 Projection ↳ Note that the text and image feature vectors from the encoders have different dimensions (3D vs. 4D). ↳ Use a linear layer to project image and text vectors to a 2D shared embedding space. 🏋️ Contrastive Pre-training 🏋️ [8] Prepare for MatMul ↳ Copy text vectors (T1,T2,T3) ↳ Copy the transpose of image vectors (I1,I2,I3) ↳ They are all in the 2D shared embedding space. [9] 🟦 MatMul ↳ Multiply T and I matrices. ↳ This is equivalent to taking dot product between every pair of image and text vectors. ↳ The purpose is to use dot product to estimate the similarity between a pair of image-text. [10] 🟦 Softmax: e^x ↳ Raise e to the power of the number in each cell ↳ To simplify hand calculation, we approximate e^□ with 3^□. [11] 🟦 Softmax: ∑ ↳ Sum each row for 🟩 image→🟪 text ↳ Sum each column for 🟪 text→ 🟩 image [12] 🟦 Softmax: 1 / sum ↳ Divide each element by the column sum to obtain a similarity matrix for 🟪 text→🟩 image ↳ Divide each element by the row sum to obtain a similarity matrix for 🟩 image→🟪 text [13] 🟥 Loss Gradients ↳ The "Targets" for the similarity matrices are Identity Matrices. ↳ Why? If I and T come from the same pair (i=j), we want the highest value, which is 1, and 0 otherwise. ↳ Apply the simple equation of [Similarity - Target] to compute gradients of for both directions. ↳ Why so simple? Because when Softmax and Cross-Entropy Loss are used together, the math magically works out that way. ↳ These gradients kick off the backpropagation process to update weights and biases of the encoders and projection layers (red borders).

Tom Yeh

67,883 views • 2 years ago

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?

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 views • 1 month ago

Microsoft CEO Satya Nadella on why winning against ChatGPT, Gemini, and Claude was never the goal: The Hard Fork hosts ask him directly how Microsoft plans to overtake the competition in the AI model race. His answer reframes the entire question. "Our real goal is to get everyone across the ecosystem to the frontier." Satya explains the problem with how frontier models are currently built. You hill climb, you do reinforcement learning, and then you need data. But at this point, the world has essentially saturated publicly available data. So the only way to keep scaling is to pull data from everywhere. He asks: "What if you turn that around and said no, there's a base model that has reasoning, that has the agent loop, but you can bring it into your RL. Every company." This is where his thinking gets interesting. Satya Nadella argues that the future of the firm runs on human capital and token capital together: "If the future of the firm is human capital and token capital, I want every balance sheet, every income statement in every company to have both." AI becomes a financial asset sitting on a company's books the same way its people do. And Microsoft's role in this? To provide the best possible base model. One that companies build on top of with their own data, their own context, their own weights. One they can even replace. That last part is the striking bit. Satya is explicitly building a platform where customers are free to walk away. He frames it not as a risk, but as the whole point: "I always ask the question — why does Microsoft, or why does the world need Microsoft? And if we are successful, can the world around us be successful? This, I believe, is a more sustainable way to go at it."

Microsoft CEO Satya Nadella on why winning against ChatGPT, Gemini, and Claude was never the goal: The Hard Fork hosts ask him directly how Microsoft plans to overtake the competition in the AI model race. His answer reframes the entire question. "Our real goal is to get everyone across the ecosystem to the frontier." Satya explains the problem with how frontier models are currently built. You hill climb, you do reinforcement learning, and then you need data. But at this point, the world has essentially saturated publicly available data. So the only way to keep scaling is to pull data from everywhere. He asks: "What if you turn that around and said no, there's a base model that has reasoning, that has the agent loop, but you can bring it into your RL. Every company." This is where his thinking gets interesting. Satya Nadella argues that the future of the firm runs on human capital and token capital together: "If the future of the firm is human capital and token capital, I want every balance sheet, every income statement in every company to have both." AI becomes a financial asset sitting on a company's books the same way its people do. And Microsoft's role in this? To provide the best possible base model. One that companies build on top of with their own data, their own context, their own weights. One they can even replace. That last part is the striking bit. Satya is explicitly building a platform where customers are free to walk away. He frames it not as a risk, but as the whole point: "I always ask the question — why does Microsoft, or why does the world need Microsoft? And if we are successful, can the world around us be successful? This, I believe, is a more sustainable way to go at it."

Big Brain AI

11,770 views • 2 months ago

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below

your agent reviewing its own work is not a check. it is a second opinion from the same source. this is the most common gap in agent systems and it hides in plain sight, because the step exists. there is a review. it just cannot do the thing you think it does. here is the mechanism. the model produced an output from a context. you then ask the same model, holding the same context, whether that output is correct. it answers fluently, because that is what it does. and the answer is drawn from the same distribution that produced the thing being judged. same weights, same window, same blind spots. if the reason the output is wrong is something the model does not know, the review does not know it either. if the reason is something the context does not contain, the review has the same context. the failure mode and the detector share a cause. > why it feels like it works because most of the time the output is fine, and the review says fine. agreement is not evidence of detection. a reviewer that says pass on everything agrees with reality most of the time too. what you actually want to measure is what happens on the cases that are wrong. that is the only place a check earns its name, and it is exactly the place where a self-review is weakest. there is research on this. Huang and colleagues at DeepMind showed at ICLR 2024 that intrinsic self-correction, revising without external grounding, does not reliably help and often makes things worse. > what to actually do move the check outside the model. a test that runs, a schema that validates, a file that exists or does not, an exit code from something you did not write. these are not smarter than the model. they are just not correlated with it, and that is the entire value. when the judgement genuinely needs a model, at minimum use a different family. same family means shared blind spots, and frontier judges measurably inflate scores for outputs that look like their own. and split the work by kind. anything objectively checkable goes to code. only the genuinely semantic calls go to a judge, and those get a rubric written as one line. a review inside the loop tells you the model is confident. a check outside it tells you whether the work is done. save this - then read the eval setup below

Hanako

14,325 views • 1 month ago

I used to stare at the hourly chart, trying to predict what would happen next—reacting, hesitating, and chasing moves I didn’t fully understand. Everything changed when I stopped relying on instinct and started treating each hour like a repeatable decision process. That showed me where the momentum was going: red or green, normal range, small doji, or large expansion. Everything truly shifted when I heard the idea of treating each hour as its own trade framework, and later when quarter logic was introduced—that was the spark. Credit where it’s due: Daye planted the seed of quarters I might not use them exactly the way he do but they are powerful for sure. With multiple TBIs injuries from the Army, I can’t trade off instinct or emotion or theory. I need structure—the same sequence, the same logic, the same decision points. That limitation forced discipline and eventually became a strength. My core rule: I don’t assume anything. I make the market prove it to me through what it has consistently done in the past via probabilities, then build a framework I can make decisions with and manage risk around—even if it isn’t an exact copy of whoever introduced the idea. So my team and I built software that analyzes each hour using data from the last 80,000+ hours of market behavior to ensure the framework is built on statistical truth. Now every hour, I’m not predicting—I’m identifying the exact probabilities behind the next likely move and executing the matching playbook. Same questions. Same rules. Same execution. And the wild part? It also works on the 3-hour chart using line structure vs. apex behavior—but that’s a lesson for another day. Free indicator in the comments. Enjoy Retweet if you go a ah ha moment in it Austin Clark

I used to stare at the hourly chart, trying to predict what would happen next—reacting, hesitating, and chasing moves I didn’t fully understand. Everything changed when I stopped relying on instinct and started treating each hour like a repeatable decision process. That showed me where the momentum was going: red or green, normal range, small doji, or large expansion. Everything truly shifted when I heard the idea of treating each hour as its own trade framework, and later when quarter logic was introduced—that was the spark. Credit where it’s due: Daye planted the seed of quarters I might not use them exactly the way he do but they are powerful for sure. With multiple TBIs injuries from the Army, I can’t trade off instinct or emotion or theory. I need structure—the same sequence, the same logic, the same decision points. That limitation forced discipline and eventually became a strength. My core rule: I don’t assume anything. I make the market prove it to me through what it has consistently done in the past via probabilities, then build a framework I can make decisions with and manage risk around—even if it isn’t an exact copy of whoever introduced the idea. So my team and I built software that analyzes each hour using data from the last 80,000+ hours of market behavior to ensure the framework is built on statistical truth. Now every hour, I’m not predicting—I’m identifying the exact probabilities behind the next likely move and executing the matching playbook. Same questions. Same rules. Same execution. And the wild part? It also works on the 3-hour chart using line structure vs. apex behavior—but that’s a lesson for another day. Free indicator in the comments. Enjoy Retweet if you go a ah ha moment in it Austin Clark

The Daily Profiler

27,535 views • 9 months ago

Finally new version of text system is released on our website ! I released as update to old version but in reality it's completely new thing in material and lot's of work in verse. I'm still working on documentation or/and videos but here is a list of good stuff it does: - Material got much lighter as slots logic moved to vertex shader. - Characters can overlap and still won't be cut out compared to old version. - Character can be animated and I already implemented some (wave, scale up/down and shake). - Custom face camera logic which works with prop scale so no need to additionally specify with and height. - Rows offset automatically when scale up or down any row. - Text effects now can be applied to any character, so words or single character. - Custom glint which works perfectly with any number of rows as a single line with multiple important controls. - Higher quality outline with two parameters to control inner and outer edge. - Timer logic split into to parts, verse and material. Verse setup initial layout and reserve slots for timer digits and then each second just sends seconds value and GPU makes timer tick freeing verse TPS by huge number. - To apply effects simply need use parsing markup with custom tag where N number between 1-9. So simply can write " Hello World" and word Hello will have rainbow effect applied. Currently implemented 4 effects. - To use icons in slots from texture array is as simple as specify another tag [iconN] where N is number of icon in array. So for example if coin is icon index 0 just need to write [icon1]100K. - Progress bar is supported as well and can be snapped to row without eyeball offset. - Background image supported now too! In the video yellow one is as test and you can use any of your own. Verse side got lots of changes: - Now saves/caches layouts better. - Smart packing of data allowed drastically reduce number of parameters, which should help with network optimization! - Instead having vector parameter per each slot to just send character index and position (32x5=160 if used 5 rows) now it's only 11 vector parameters per each row so 11x5=55 which is huge save and it sends text effects index in it too! - Implemented text update queue for text which doesn't require instant update. It helps to give more breathing for other text props which needs that speed. - Materials code now use interface and wrappers for cleaner work. If you still read it then thank you! :) On our website we now run 25% sale! And if you own old version please DM me here or in Discord and I will give you promo code for 100% discount on our website! Gelos Games Fortnite #uefn #EpicPartner

Finally new version of text system is released on our website ! I released as update to old version but in reality it's completely new thing in material and lot's of work in verse. I'm still working on documentation or/and videos but here is a list of good stuff it does: - Material got much lighter as slots logic moved to vertex shader. - Characters can overlap and still won't be cut out compared to old version. - Character can be animated and I already implemented some (wave, scale up/down and shake). - Custom face camera logic which works with prop scale so no need to additionally specify with and height. - Rows offset automatically when scale up or down any row. - Text effects now can be applied to any character, so words or single character. - Custom glint which works perfectly with any number of rows as a single line with multiple important controls. - Higher quality outline with two parameters to control inner and outer edge. - Timer logic split into to parts, verse and material. Verse setup initial layout and reserve slots for timer digits and then each second just sends seconds value and GPU makes timer tick freeing verse TPS by huge number. - To apply effects simply need use parsing markup with custom tag where N number between 1-9. So simply can write " Hello World" and word Hello will have rainbow effect applied. Currently implemented 4 effects. - To use icons in slots from texture array is as simple as specify another tag [iconN] where N is number of icon in array. So for example if coin is icon index 0 just need to write [icon1]100K. - Progress bar is supported as well and can be snapped to row without eyeball offset. - Background image supported now too! In the video yellow one is as test and you can use any of your own. Verse side got lots of changes: - Now saves/caches layouts better. - Smart packing of data allowed drastically reduce number of parameters, which should help with network optimization! - Instead having vector parameter per each slot to just send character index and position (32x5=160 if used 5 rows) now it's only 11 vector parameters per each row so 11x5=55 which is huge save and it sends text effects index in it too! - Implemented text update queue for text which doesn't require instant update. It helps to give more breathing for other text props which needs that speed. - Materials code now use interface and wrappers for cleaner work. If you still read it then thank you! :) On our website we now run 25% sale! And if you own old version please DM me here or in Discord and I will give you promo code for 100% discount on our website! Gelos Games Fortnite #uefn #EpicPartner

AsicsoN

13,275 views • 3 months ago

The explanation that the pyramids were built by lifting stones weighing hundreds of thousands of pounds with sticks has, Shawn Ryan suggests, run its course. Few people with any serious engagement with the evidence are still buying it - and yet it persists in educational systems as though the question were settled. Shawn finds that persistence almost more puzzling than the construction mystery itself. The scale of the problem becomes clear when you stop treating each site as an isolated anomaly. Randall draws on his own experience moving heavy weights in construction - noting that even a single ton beam requires cranes and front end loaders today - and applies that practical knowledge directly to the ancient record. The ancient world was moving stones of 100, 200 tons and beyond, not once at a single location but repeatedly, across every inhabited continent, in cultures with no documented contact with one another. Stonehenge, Easter Island, Machu Picchu, and the pyramids are not separate puzzles with separate solutions. They are the same question asked in different languages - and the answer, Randall argues, is one that the stick and ramp theory was never equipped to provide.

The explanation that the pyramids were built by lifting stones weighing hundreds of thousands of pounds with sticks has, Shawn Ryan suggests, run its course. Few people with any serious engagement with the evidence are still buying it - and yet it persists in educational systems as though the question were settled. Shawn finds that persistence almost more puzzling than the construction mystery itself. The scale of the problem becomes clear when you stop treating each site as an isolated anomaly. Randall draws on his own experience moving heavy weights in construction - noting that even a single ton beam requires cranes and front end loaders today - and applies that practical knowledge directly to the ancient record. The ancient world was moving stones of 100, 200 tons and beyond, not once at a single location but repeatedly, across every inhabited continent, in cultures with no documented contact with one another. Stonehenge, Easter Island, Machu Picchu, and the pyramids are not separate puzzles with separate solutions. They are the same question asked in different languages - and the answer, Randall argues, is one that the stick and ramp theory was never equipped to provide.

Randall Carlson

41,347 views • 5 months ago

What am I looking at, and how did we get here? These children are between 3 and 6 years old. Look closely at this video. These are not teenagers experimenting with drugs. These are babies. At an age when a child should be playing, learning colours, asking endless questions and running around without a care in the world, we are watching them being introduced to smoking. And that should frighten every parent. It should frighten every teacher. It should frighten every community. It should frighten the government. Because addiction doesn't always begin with a hard drug. Sometimes it begins with something adults dismiss as “just shisha.” Then curiosity becomes experimentation. Experimentation becomes a habit. The habit becomes dependence. And before we realize what has happened, a child who should be building a future is fighting an addiction. The developing brain is particularly vulnerable to nicotine and other addictive substances. Early exposure can affect attention, learning, impulse control and increase the risk of dependence later in life. So I want us to have an uncomfortable conversation this week. What exactly are we exposing the next generation to? Where are the parents? Where are the adults? Where are the schools? Where are the regulators? Where is the government? And most importantly… What kind of generation are we creating if we allow children to grow up thinking this is normal? I'm starting a series on substance abuse this week. We are going to talk about the brain. The body. Addiction. Parents. Peer pressure. Drug dealers. Social media. Government agencies. Rehabilitation. And the uncomfortable truth about how addiction can begin. Don't scroll past this. The child in this video could be someone's son, daughter, brother, sister or even your own child tomorrow. We need to talk. What am I looking at, and how did we get here?

What am I looking at, and how did we get here? These children are between 3 and 6 years old. Look closely at this video. These are not teenagers experimenting with drugs. These are babies. At an age when a child should be playing, learning colours, asking endless questions and running around without a care in the world, we are watching them being introduced to smoking. And that should frighten every parent. It should frighten every teacher. It should frighten every community. It should frighten the government. Because addiction doesn't always begin with a hard drug. Sometimes it begins with something adults dismiss as “just shisha.” Then curiosity becomes experimentation. Experimentation becomes a habit. The habit becomes dependence. And before we realize what has happened, a child who should be building a future is fighting an addiction. The developing brain is particularly vulnerable to nicotine and other addictive substances. Early exposure can affect attention, learning, impulse control and increase the risk of dependence later in life. So I want us to have an uncomfortable conversation this week. What exactly are we exposing the next generation to? Where are the parents? Where are the adults? Where are the schools? Where are the regulators? Where is the government? And most importantly… What kind of generation are we creating if we allow children to grow up thinking this is normal? I'm starting a series on substance abuse this week. We are going to talk about the brain. The body. Addiction. Parents. Peer pressure. Drug dealers. Social media. Government agencies. Rehabilitation. And the uncomfortable truth about how addiction can begin. Don't scroll past this. The child in this video could be someone's son, daughter, brother, sister or even your own child tomorrow. We need to talk. What am I looking at, and how did we get here?

Sheila O.

233,879 views • 19 days ago

The People Who Cannot Be Helped At times, when I see Kenyans being forcefully displaced, brutalised, and robbed by British-backed war criminal and mass murderer William Ruto, I feel the strong urge to start a space, go live, or call for protests. Then reality hits. These are the same people who loudly complained that maandamano was ruining their small businesses. These are the same people who wake up every morning to poison their minds with Kameme and Inooro. These are the same people who still believe Rigathi Gachagua is their saviour. These are the same people who follow DCI bloggers during protests so they can know exactly where the police roadblocks and unmarked Subarus are. These are the same people who faithfully watch degenerate talk show host Jeff Koinange. These are the same people who consume brain-evaporating content from Githaiga wa Chai, Peter Kioi, Prince Mwiti, and Geoffrey Mosiria. These are the same people who pack Pastor Victor Kanyari’s church to be preached to by reformed hooker Marion Naipei. They really and truly cannot be helped. No matter how many times they are displaced from their homes, no matter how many of their children are killed or disappeared, no matter how deep the poverty and oppression sink, they remain glued to the same cycle of tribal delusion, religious escapism, and media addiction. They will curse the government today and rush to defend its puppets tomorrow. They will complain about suffering while actively supporting the very system manufacturing it. There comes a point where you must accept that some people have willingly chosen their chains. They prefer the familiar comfort of oppression, the emotional high of Kameme propaganda, the false hope of Gathuri Bosco Rigathi Gachagua, and the brain-rotting entertainment from their favourite content creators over the difficult work of genuine awakening and resistance. You cannot save people who are committed to their own mental slavery. The energy is better spent on those who are truly awake, those who see through the scam, and those willing to break the cycle. The rest have made their choice. Let them live - and suffer - with the consequences.

The People Who Cannot Be Helped At times, when I see Kenyans being forcefully displaced, brutalised, and robbed by British-backed war criminal and mass murderer William Ruto, I feel the strong urge to start a space, go live, or call for protests. Then reality hits. These are the same people who loudly complained that maandamano was ruining their small businesses. These are the same people who wake up every morning to poison their minds with Kameme and Inooro. These are the same people who still believe Rigathi Gachagua is their saviour. These are the same people who follow DCI bloggers during protests so they can know exactly where the police roadblocks and unmarked Subarus are. These are the same people who faithfully watch degenerate talk show host Jeff Koinange. These are the same people who consume brain-evaporating content from Githaiga wa Chai, Peter Kioi, Prince Mwiti, and Geoffrey Mosiria. These are the same people who pack Pastor Victor Kanyari’s church to be preached to by reformed hooker Marion Naipei. They really and truly cannot be helped. No matter how many times they are displaced from their homes, no matter how many of their children are killed or disappeared, no matter how deep the poverty and oppression sink, they remain glued to the same cycle of tribal delusion, religious escapism, and media addiction. They will curse the government today and rush to defend its puppets tomorrow. They will complain about suffering while actively supporting the very system manufacturing it. There comes a point where you must accept that some people have willingly chosen their chains. They prefer the familiar comfort of oppression, the emotional high of Kameme propaganda, the false hope of Gathuri Bosco Rigathi Gachagua, and the brain-rotting entertainment from their favourite content creators over the difficult work of genuine awakening and resistance. You cannot save people who are committed to their own mental slavery. The energy is better spent on those who are truly awake, those who see through the scam, and those willing to break the cycle. The rest have made their choice. Let them live - and suffer - with the consequences.

Francis Gaitho

27,704 views • 2 months ago

This is probably the most complex workflow I’ve ever built, only with open-source tools. It took my 4 days. It takes four inputs: author, title, and style; and generates a full visual animated story in one click in ComfyUI . I worked on it for four days. There are still some bugs, but here’s the first preview. Here’s a quick breakdown: - The four inputs are sent to LLMs with precise instructions to generate: first, prompts for images and image modifications; second, prompts for animations; third, prompts for generating music. - All voices are generated from the text and timed precisely, as they determine the length of each animation segment. - The first image and video are generated to serve as the title, but also as the guide for all other images created for the video. - Titles and subtitles are also added automatically in Comfy. - I also developed a lot of custom nodes for minor frame calculations, mostly to match audio and video. - The full system is a large loop that, for each line of text, generates an image and then a video from that image. The loop was the hardest part to build in this workflow, so it can process either a 20-second video or a 2-minute video with the same input. - There are multiple combinations of LLMs that try to understand the text in the best way to provide the best prompts for images and video. - The final video is assembled entirely within ComfyUI. - The music is generated based on the LLM output and matches the exact timing of the full animation. - Done! For reference, this workflow uses a lot of models and only works on an RTX 6000 Pro with plenty of RAM. My goal is not to replace humans, as I’ll try to explain later, this workflow is highly controlled and can be adapted or reworked at any point by real artists! My aim was to create a tool that can animate text in one go, allowing the AI some freedom while keeping a strict flow. I don’t know yet how I’ll share this workflow with people, I still need to polish it properly, but maybe through Patreon. Anyway, I hope you enjoy my research, and let’s always keep pushing further! :)

This is probably the most complex workflow I’ve ever built, only with open-source tools. It took my 4 days. It takes four inputs: author, title, and style; and generates a full visual animated story in one click in ComfyUI . I worked on it for four days. There are still some bugs, but here’s the first preview. Here’s a quick breakdown: - The four inputs are sent to LLMs with precise instructions to generate: first, prompts for images and image modifications; second, prompts for animations; third, prompts for generating music. - All voices are generated from the text and timed precisely, as they determine the length of each animation segment. - The first image and video are generated to serve as the title, but also as the guide for all other images created for the video. - Titles and subtitles are also added automatically in Comfy. - I also developed a lot of custom nodes for minor frame calculations, mostly to match audio and video. - The full system is a large loop that, for each line of text, generates an image and then a video from that image. The loop was the hardest part to build in this workflow, so it can process either a 20-second video or a 2-minute video with the same input. - There are multiple combinations of LLMs that try to understand the text in the best way to provide the best prompts for images and video. - The final video is assembled entirely within ComfyUI. - The music is generated based on the LLM output and matches the exact timing of the full animation. - Done! For reference, this workflow uses a lot of models and only works on an RTX 6000 Pro with plenty of RAM. My goal is not to replace humans, as I’ll try to explain later, this workflow is highly controlled and can be adapted or reworked at any point by real artists! My aim was to create a tool that can animate text in one go, allowing the AI some freedom while keeping a strict flow. I don’t know yet how I’ll share this workflow with people, I still need to polish it properly, but maybe through Patreon. Anyway, I hope you enjoy my research, and let’s always keep pushing further! :)

Lovis Odin

58,841 views • 11 months ago

The most dangerous thing a company can do right now is rent intelligence from the same place as its competitors (Save this). You cannot rent intelligence from the same place that rents it to your competitor as Chamath Palihapitiya points out. If every company in an industry is feeding their workflows into the same frontier model, they are all converging on the same outputs, the same decisions, the same product improvements. The model becomes the equalizer and everyone pays a premium to become more mediocre. This is happening exactly as Chamath predicted, and the evidence is now concrete. Anthropic and OpenAI have established what analysts are now openly calling an emerging model layer duopoly. Anthropic crossed $45 billion ARR in may 2026, more than tripling from $9 billion at the end of 2025, OpenAI was at roughly $24 to $33 billion ARR at the same time. Together, the two companies combined could hit $160 to $240 billion ARR by end of 2026 and Anthropic and OpenAI now control 88% of enterprise LLM spend. That concentration is the structural problem Chamath is pointing at. And Anthropic isn't just winning on merit because it's actively lobbying for regulatory outcomes that would make that duopoly permanent. Dario Amodei has explicitly framed open source models as unsafe, pushing a safety agenda that, if enshrined in regulation, would effectively make it illegal for enterprises to use the cheaper, private, sovereign alternatives locking them into a closed model dependency by government decree rather than by choice. So you have market forces producing a duopoly, and potential regulatory capture moving to enforce it from the top down. This is exactly why the Nvidia Palantir partnership is not just a product announcement but rather a strategic counter to that duopoly. The logic is straightforward from both sides because If you're Palantir, sitting at the application layer, the last thing you want is to be permanently beholden to Anthropic or OpenAI for the intelligence that powers your product. You want competitive model options, sovereignty and be able to tell enterprise customers they can run AI on their own infrastructure with their own data without any of it touching a frontier lab's servers. If you're Nvidia, sitting at the chip layer, an Anthropic-OpenAI duopoly is an existential concentration risk. Right now, Meta, Google, Microsoft, Amazon, and dozens of other companies buy Nvidia's hardware. If the model layer consolidates into two players, both of which are building their own chips Nvidia faces a monopsony where its best customers are building the tools to displace it. A healthy open source ecosystem where thousands of enterprises train, fine tune, and deploy their own models is Nvidia's ideal market structure. More buyers, more diversity, more demand, less pricing leverage from any single customer.

The most dangerous thing a company can do right now is rent intelligence from the same place as its competitors (Save this). You cannot rent intelligence from the same place that rents it to your competitor as Chamath Palihapitiya points out. If every company in an industry is feeding their workflows into the same frontier model, they are all converging on the same outputs, the same decisions, the same product improvements. The model becomes the equalizer and everyone pays a premium to become more mediocre. This is happening exactly as Chamath predicted, and the evidence is now concrete. Anthropic and OpenAI have established what analysts are now openly calling an emerging model layer duopoly. Anthropic crossed $45 billion ARR in may 2026, more than tripling from $9 billion at the end of 2025, OpenAI was at roughly $24 to $33 billion ARR at the same time. Together, the two companies combined could hit $160 to $240 billion ARR by end of 2026 and Anthropic and OpenAI now control 88% of enterprise LLM spend. That concentration is the structural problem Chamath is pointing at. And Anthropic isn't just winning on merit because it's actively lobbying for regulatory outcomes that would make that duopoly permanent. Dario Amodei has explicitly framed open source models as unsafe, pushing a safety agenda that, if enshrined in regulation, would effectively make it illegal for enterprises to use the cheaper, private, sovereign alternatives locking them into a closed model dependency by government decree rather than by choice. So you have market forces producing a duopoly, and potential regulatory capture moving to enforce it from the top down. This is exactly why the Nvidia Palantir partnership is not just a product announcement but rather a strategic counter to that duopoly. The logic is straightforward from both sides because If you're Palantir, sitting at the application layer, the last thing you want is to be permanently beholden to Anthropic or OpenAI for the intelligence that powers your product. You want competitive model options, sovereignty and be able to tell enterprise customers they can run AI on their own infrastructure with their own data without any of it touching a frontier lab's servers. If you're Nvidia, sitting at the chip layer, an Anthropic-OpenAI duopoly is an existential concentration risk. Right now, Meta, Google, Microsoft, Amazon, and dozens of other companies buy Nvidia's hardware. If the model layer consolidates into two players, both of which are building their own chips Nvidia faces a monopsony where its best customers are building the tools to displace it. A healthy open source ecosystem where thousands of enterprises train, fine tune, and deploy their own models is Nvidia's ideal market structure. More buyers, more diversity, more demand, less pricing leverage from any single customer.

Milk Road AI

34,385 views • 2 months ago

a shape with no inside. he filled it with water anyway pour water in and it stops almost immediately. the air has nowhere to escape, so it just sits there blocking you. tilt it and you get a little more in, then it blocks again so he put the whole thing in a vacuum chamber turn it on and the bottle starts bubbling. that's the air being pulled out through the neck, leaving as close to nothing inside as he can get then he lets the pressure back in, and the water rushes up into the empty space on its own still not full. so he runs it again, rarefying the smaller pocket of air that's left, and again after that here's the part that breaks your head: for a shape to have volume, it has to split the world in two. a ball does that. stretch it however you want, there's always a world inside and a world outside a Klein bottle has no such line. follow its surface and you never cross a boundary, never pass through a wall, never end up anywhere that isn't the same side you started on the inside is the outside. so there's nothing there to fill he filled it anyway that's the same shape as the room below. no plot, no payoff, just a question your brain won't drop -> can a thing with no inside hold anything at all two videos, two impossible questions, 20 million views between them. Paone broke down why this format works in the article underneath save this. the most watched thing today was a shape that shouldn't be able to hold anything, holding water

a shape with no inside. he filled it with water anyway pour water in and it stops almost immediately. the air has nowhere to escape, so it just sits there blocking you. tilt it and you get a little more in, then it blocks again so he put the whole thing in a vacuum chamber turn it on and the bottle starts bubbling. that's the air being pulled out through the neck, leaving as close to nothing inside as he can get then he lets the pressure back in, and the water rushes up into the empty space on its own still not full. so he runs it again, rarefying the smaller pocket of air that's left, and again after that here's the part that breaks your head: for a shape to have volume, it has to split the world in two. a ball does that. stretch it however you want, there's always a world inside and a world outside a Klein bottle has no such line. follow its surface and you never cross a boundary, never pass through a wall, never end up anywhere that isn't the same side you started on the inside is the outside. so there's nothing there to fill he filled it anyway that's the same shape as the room below. no plot, no payoff, just a question your brain won't drop -> can a thing with no inside hold anything at all two videos, two impossible questions, 20 million views between them. Paone broke down why this format works in the article underneath save this. the most watched thing today was a shape that shouldn't be able to hold anything, holding water

Banff

2,567,785 views • 1 month ago

Just how capable are open source models? Below is the first in a new series where we go behind the scenes and pull back the curtain on interesting AI research / demos, making them fun and easy to understand. Here, we have a short visual demonstration from aizk ✡️ showcasing how Kimi K3 (a language model that operates primarily through text) is capable of building complicated 3D structures / moments in history in Minecraft, something that previously was not possible with other open source models, and why this matters. The crazy part? The model doesn't "see" the game like we do. The LLMs must reason in pure text, writing JavaScript, that later compiles down into commands placing each block, one at a time. Spatial reasoning is a very hard problem in AI, it's the same core challenge behind robotics and self-driving cars, where a model has to understand and act in physical 3D space. Watching a text model pull it off is nothing short of a miracle. The point isn't just Minecraft itself, rather, it's AI being able to generalize, not memorize, on things that are weird and beyond their training data. This is key to building true artificial general intelligence. These video game benchmarks (there are many different games actively being researched right now) provide a clear-cut end goal, challenges that are almost certainly not in the training set, and a fun, very fast, visual way to almost feel the increasing capabilities of various open source AI models over time. If you haven't given open source models a serious try yet, watch the video, it may shock you!

Just how capable are open source models? Below is the first in a new series where we go behind the scenes and pull back the curtain on interesting AI research / demos, making them fun and easy to understand. Here, we have a short visual demonstration from aizk ✡️ showcasing how Kimi K3 (a language model that operates primarily through text) is capable of building complicated 3D structures / moments in history in Minecraft, something that previously was not possible with other open source models, and why this matters. The crazy part? The model doesn't "see" the game like we do. The LLMs must reason in pure text, writing JavaScript, that later compiles down into commands placing each block, one at a time. Spatial reasoning is a very hard problem in AI, it's the same core challenge behind robotics and self-driving cars, where a model has to understand and act in physical 3D space. Watching a text model pull it off is nothing short of a miracle. The point isn't just Minecraft itself, rather, it's AI being able to generalize, not memorize, on things that are weird and beyond their training data. This is key to building true artificial general intelligence. These video game benchmarks (there are many different games actively being researched right now) provide a clear-cut end goal, challenges that are almost certainly not in the training set, and a fun, very fast, visual way to almost feel the increasing capabilities of various open source AI models over time. If you haven't given open source models a serious try yet, watch the video, it may shock you!

Featherless AI

39,769 views • 20 days ago