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.

FIGMA-OS: The first Turing-complete Figma file. SPECS: 8-bit architecture, 512 bits of RAM, 16 bytes of Program Memory, MISC instruction set of 16 OPCODES, 10HZ clock speed, 4 fast access registers, binary-tree RAM/ROM memory. MOTIVATIONS: For the meme. HOW: Explained below.

will depue

71,898 subscribers

362,825 views • 3 years ago •via X (Twitter)

Gaming Education Science & Technology

Anya Rossi• Live Now

Private livecam show

15 Comments

will depue3 years ago

FIGMA-OS has every feature that any modern, enterprising technologist could possibly need: ► A stunning and detailed user manual. ► Useful pre-installed programs like: Fibonacci Numbers. ► An award-winning graphical user interface.

will depue3 years ago

FIGMA-OS has been generously open-sourced to serve all your computing needs, live on the Figma Community today. ▼ Try our demo ▼ ▼ Duplicate FIGMA-OS and see it for yourself ▼

will depue3 years ago

----- Ok so on Wednesday, Figma released new prototyping tools. After seeing their tweet (at 1AM) I knew I had to be the first to build a working computer. If you want to read me trying to figure how to build this late at night, check out this thread.

will depue3 years ago

The goal was really just to mess with the prototyping PM that woke up to my computer on day one. Shoutout to the team for an insanely stable launch + great features. I'll do a writeup of how this all works soon (it's pretty easy actually). But here's a quick simplification:

will depue3 years ago

Computers are made out of very simple parts (think mostly switches and wires). If you can make extremely simple circuits (AND, OR, NOT) you can build a computer. They're also universal, meaning my Figma PC can technically do anything your Macbook can, with infinite space/time.

will depue3 years ago

Figma-OS is a MISC computer (look that up), here's the key parts: - Random Access Memory - Read-Only Memory, to store programs (can't be changed) - Instruction Set (16 different operators) - CPU "Clock", registers, and a counter to run ops. - Programs, made up of instructions.

will depue3 years ago

RAM is just read and write storage here, which lets you store and load 8 bit numbers (0 -> 255). ROM is simpler memory that can't change and stores the list of instructions to run a program in order. Each part of memory is addressed by a unique number for retrieval, see below.

will depue3 years ago

Each memory slot is a Figma number variable. Since I'm doing operations in binary, I need to convert numbers to binary and back when loading/storing. This requires a de/composition algorithm to do these conversions. While a bit slower this allows 8x the computer memory in Figma.

will depue3 years ago

Registers, as seen above, are just temporary storage that you can put data in and do operations on that data. A lot of programs might pull data from memory, do an operation on it in the register, and put it back. A register is simply 8 different boolean variables in Figma.

will depue3 years ago

There's 16 different instructions (10 unique operators). Loading from memory, storing from memory, jumping to a different point in the program, bitshift register, bitwise not register, output data, stop program. With these 16 operations, you can do nearly any computation.

will depue3 years ago

Instructions come in the form of an ADDRESS (ex: 0001) and a OPCODE (ex: 0110) and. These are joined together (ex: 00010110), converted to numbers (22), and saved in ROM. The computer reads these codes sequentially, converts to binary, and then runs the respective instruction.

will depue3 years ago

The computer uses a program counter to know which OPCODE to run. Every time an operation is run, the program counter is incremented and the next program is run (or JUMP commands, which directly edit the counter).

will depue3 years ago

There were many workarounds and hacks to get this all to work. Obviously, Figma wasn't designed for this. Since I can run code when a slide loads, the structure is like a presentation that keeps jumping to the next slide in a loop, taking different turns each time.

will depue3 years ago

If you're interested in learning more, stick around until I release a post that goes into detail + simply explains how the system works. If you want to check it out yourself, see the Figma. It's surprisingly simple to understand just by poking through.

will depue3 years ago

Also, @zoink @figma can a homie get some merch for building the first Figma CPU? Taught myself design on Figma, massive fan of the product + I'm the only guy on the planet who uses Figma as his IDE.

Related Videos

$PrismML Releases Bonsai 27B: 1-bit and Ternary Builds of Qwen3.6-27B Hitting 89.5% of FP16 at 3.9GB. No new pretrain. No higher-precision escape hatches. No multi-GPU rig. Here's how it works. 👇 1: Codes, not floats Every weight becomes a code, with one shared FP16 scale per group of 128. Ternary is {−1, 0, +1}, binary is {−1, +1}. Sharing the scale across 128 weights keeps its cost at 16/128 = 0.125 bits. → Ternary: log2(3) + 16/128 ≈ 1.71 bits/weight → 5.9GB → Binary: 1 + 16/128 = 1.125 bits/weight → 3.9GB 2: Post-training, not from scratch No BitNet-style low-bit pretrain. It starts from off-the-shelf Qwen3.6-27B, architecture unchanged. The representation runs end to end across embeddings, attention projections, MLP projections, and the LM head. → 9.4× (ternary) and 14.2× (binary) vs the 54GB FP16 baseline 3: Labels are not bit-widths Conventional low-bit builds are mixed-precision by construction. The advertised name describes the most-compressed tensors, not the model. → Q4_K_XL, labeled "4-bit," is really 5.2 bits/weight at 17.6GB → IQ2_XXS, labeled "2-bit," is really 2.8 bits/weight at 9.4GB 4: Fitting a phone is two budgets iOS caps a single app near half of RAM, so a 12GB iPhone exposes ~6GB. The KV cache grows on top. Hybrid attention at ~75% linear means only 16 of 64 layers cache. → 4-bit KV: 4.3GB at 262K context, down from 17.2GB → 11.0 tok/s on iPhone 17 Pro Max 5: The numbers (15 benchmarks, thinking mode) → Ternary: 80.49 avg at 5.9GB — 94.6% of FP16 → 1-bit: 76.11 avg at 3.9GB — 89.5% of FP16 → IQ2_XXS falls to 57.5 on AIME26 while still scoring 88.93 on MMLU-Redux The key takeaway: 27B-class reasoning without the 54GB checkpoint — group-wise ternary and binary codes, an end-to-end low-bit language stack, 4-bit KV, on one phone. Full analysis: Repo: Model weight: Technical details: PrismML$

PrismML Releases Bonsai 27B: 1-bit and Ternary Builds of Qwen3.6-27B Hitting 89.5% of FP16 at 3.9GB. No new pretrain. No higher-precision escape hatches. No multi-GPU rig. Here's how it works. 👇 1: Codes, not floats Every weight becomes a code, with one shared FP16 scale per group of 128. Ternary is {−1, 0, +1}, binary is {−1, +1}. Sharing the scale across 128 weights keeps its cost at 16/128 = 0.125 bits. → Ternary: log2(3) + 16/128 ≈ 1.71 bits/weight → 5.9GB → Binary: 1 + 16/128 = 1.125 bits/weight → 3.9GB 2: Post-training, not from scratch No BitNet-style low-bit pretrain. It starts from off-the-shelf Qwen3.6-27B, architecture unchanged. The representation runs end to end across embeddings, attention projections, MLP projections, and the LM head. → 9.4× (ternary) and 14.2× (binary) vs the 54GB FP16 baseline 3: Labels are not bit-widths Conventional low-bit builds are mixed-precision by construction. The advertised name describes the most-compressed tensors, not the model. → Q4_K_XL, labeled "4-bit," is really 5.2 bits/weight at 17.6GB → IQ2_XXS, labeled "2-bit," is really 2.8 bits/weight at 9.4GB 4: Fitting a phone is two budgets iOS caps a single app near half of RAM, so a 12GB iPhone exposes ~6GB. The KV cache grows on top. Hybrid attention at ~75% linear means only 16 of 64 layers cache. → 4-bit KV: 4.3GB at 262K context, down from 17.2GB → 11.0 tok/s on iPhone 17 Pro Max 5: The numbers (15 benchmarks, thinking mode) → Ternary: 80.49 avg at 5.9GB — 94.6% of FP16 → 1-bit: 76.11 avg at 3.9GB — 89.5% of FP16 → IQ2_XXS falls to 57.5 on AIME26 while still scoring 88.93 on MMLU-Redux The key takeaway: 27B-class reasoning without the 54GB checkpoint — group-wise ternary and binary codes, an end-to-end low-bit language stack, 4-bit KV, on one phone. Full analysis: Repo: Model weight: Technical details: PrismML

Marktechpost AI

31,860 views • 1 month ago

Finally, we have published Horizon OS UI Set for ISDK-Unity and Figma with the Interaction SDK v69 release on 10/9! This is our first public release of official UI components and design resources based on the Quest Design System. UI Set for Meta XR Interaction SDK: Figma Design file: By using UI Set, you can achieve consistent input modality support, visual feedback, and interaction behaviors. In addition to UI components and common UI pattern examples, theming capability can help you bring your own brand identity into your UI. We hope these UI Set Unity components + Figma design assets + Guideline docs - can help you designers, developers, and creators design, experiment, and build great spatial app experiences for Horizon OS platform. Including a personal blog post - How to build a simple spatial panel app with Meta Horizon OS UI Set, an image viewer with NASA Mars Rover API: #MetaQuest #MixedReality #MetaHorizonOS #InteractionSDK #MetaXRSDK #SpatialComputing

Yoon Park (박동윤)

59,258 views • 1 year ago

GPU by hand ✍️ I drew 42 frames to show how a GPU speeds up an array operation of 8 elements in parallel over 4 threads in 2 clock cycles. Below is an overview: CPU • It has one core. • Its global memory has 120 locations (0-119). • To use the GPU, it needs to copy data from the global memory to the GPU. • After GPU is done, it will copy the results back. GPU • It has four cores to run four threads (0-3). • It has a register file of 28 locations (0-27) • This register file has four banks (0-3). • All threads share the same register file. • But they must read/write using the four banks. • Each bank allows 2 reads (Read 0, Read 1) and 1 write in a single clock cycle.

GPU by hand ✍️ I drew 42 frames to show how a GPU speeds up an array operation of 8 elements in parallel over 4 threads in 2 clock cycles. Below is an overview: CPU • It has one core. • Its global memory has 120 locations (0-119). • To use the GPU, it needs to copy data from the global memory to the GPU. • After GPU is done, it will copy the results back. GPU • It has four cores to run four threads (0-3). • It has a register file of 28 locations (0-27) • This register file has four banks (0-3). • All threads share the same register file. • But they must read/write using the four banks. • Each bank allows 2 reads (Read 0, Read 1) and 1 write in a single clock cycle.

Tom Yeh

101,788 views • 1 year ago

Martin Keen from IBM just explained the one thing separating "chatbot users" from $300K AI architects > most people use Claude Opus 4.8 as a temporary tool -> the pros build it a permanent memory it's called the CoALA framework. the 4 layers your agent actually needs: > Working Memory - the context window. fast but resets every session. this is the RAM, not the brain > Semantic Memory - your knowledge base. CLAUDE.md, rules, facts the agent never forgets regardless of session > Procedural Memory - skills. workflows and instructions that load only when a specific task begins > Episodic Memory - past lessons. the agent remembers every bug it fixed yesterday so it doesn't repeat it today if your agent doesn't have all four, it's a fancy autocomplete the 2026 job market isn't looking for prompt engineers > it's looking for people who can build AI brains - and the ones doing it now aren't waiting for job postings save this or watch someone else use it to get your next raise 👇

Martin Keen from IBM just explained the one thing separating "chatbot users" from $300K AI architects > most people use Claude Opus 4.8 as a temporary tool -> the pros build it a permanent memory it's called the CoALA framework. the 4 layers your agent actually needs: > Working Memory - the context window. fast but resets every session. this is the RAM, not the brain > Semantic Memory - your knowledge base. CLAUDE.md, rules, facts the agent never forgets regardless of session > Procedural Memory - skills. workflows and instructions that load only when a specific task begins > Episodic Memory - past lessons. the agent remembers every bug it fixed yesterday so it doesn't repeat it today if your agent doesn't have all four, it's a fancy autocomplete the 2026 job market isn't looking for prompt engineers > it's looking for people who can build AI brains - and the ones doing it now aren't waiting for job postings save this or watch someone else use it to get your next raise 👇

Mr. Buzzoni

10,442 views • 2 months ago

Your OpenClaw🦞 agent works perfectly for 20 minutes. Then it silently forgets your instructions and goes rogue. The fix isn't better prompts. It's understanding how memory actually works. I'm an OpenClaw maintainer. After 2+ months of daily use, I ended up with a memory system where my agent remembers decisions from weeks ago, checks its notes before acting, and picks up exactly where it left off after every restart: 0:00 The real reason your agent forgets 1:59 Quick start: 3 things that matter most 3:01 The 4 "memories" people confuse 4:52 3 failure modes: why your agent forgets 6:42 Compaction vs pruning 8:05 Prove what's loaded: /context list 10:06 What compaction actually does 13:42 Layer 1: pre-compaction memory flush 16:27 Layer 2: manual saves + /compact trick 19:12 Layer 3: the file architecture 23:22 The memory protocol for AGENTS.md 26:06 Retrieval: Track A, A+, and QMD by tobi lutke 31:59 Cost and cache 33:33 The complete config (copy and go) 36:35 5 things to remember

Your OpenClaw🦞 agent works perfectly for 20 minutes. Then it silently forgets your instructions and goes rogue. The fix isn't better prompts. It's understanding how memory actually works. I'm an OpenClaw maintainer. After 2+ months of daily use, I ended up with a memory system where my agent remembers decisions from weeks ago, checks its notes before acting, and picks up exactly where it left off after every restart: 0:00 The real reason your agent forgets 1:59 Quick start: 3 things that matter most 3:01 The 4 "memories" people confuse 4:52 3 failure modes: why your agent forgets 6:42 Compaction vs pruning 8:05 Prove what's loaded: /context list 10:06 What compaction actually does 13:42 Layer 1: pre-compaction memory flush 16:27 Layer 2: manual saves + /compact trick 19:12 Layer 3: the file architecture 23:22 The memory protocol for AGENTS.md 26:06 Retrieval: Track A, A+, and QMD by tobi lutke 31:59 Cost and cache 33:33 The complete config (copy and go) 36:35 5 things to remember

Radek Sienkiewicz

94,629 views • 6 months ago

Google Ironwood TPU Memory Hierarchy in 9 levels by hand ✍️ 1. Bit – The most basic unit of information, the on–off decision from which every number, tensor, and model state is ultimately constructed. 2. FP8 (1×8 → 8 bits) – Eight bits are grouped to form a floating-point value, typically used for inference, where reduced precision is a deliberate trade-off to maximize throughput and efficiency. 3. BF16 (×2 → 16 bits) – Two FP8-scale chunks are combined to gain more dynamic range and stability, while still staying friendly to high-throughput hardware. 4. Tensor tile (×1024 → 1K) – Data moves through the chip in blocks of 1024 values at a time, defining the granularity at which tensors are fetched and manipulated. 5. Matrix Multiplication Unit (MXU) (×64 → 64K) – A systolic array where matrix multiplication is not abstract but physical, with tensor tiles flowing through fixed hardware to achieve the highest possible throughput. 6. Vector Memory (VMEM) (×2048 → 128M) – On-chip working memory that holds activations, partial results, and intermediates, sized specifically to keep the systolic array busy without stalling. 7. Common Memory (CMEM) (×8 → 1 GB) – A small but critical shared memory sitting between VMEM and HBM, used for staging, accumulation, synchronization, and cross-lane coordination. 8. HBM (×96 → 96 GB) – Off-chip high-bandwidth memory where model weights and large states live, implemented as HBM3e with 16 stacks at 6 GB each, for a total of 96 GB. 9. Dual-Die (x2 → 192GB) – Two tightly coupled compute dies operate as a single logical accelerator, each with its own local HBM, effectively doubling memory capacity and bandwidth while allowing tensors and activations to stream seamlessly across dies as if they lived on one chip. I created this drawing for this week's seminar. I’ll take you through these 9 levels in a beginner-friendly way by hand ✍️. RSVP 👉

Google Ironwood TPU Memory Hierarchy in 9 levels by hand ✍️ 1. Bit – The most basic unit of information, the on–off decision from which every number, tensor, and model state is ultimately constructed. 2. FP8 (1×8 → 8 bits) – Eight bits are grouped to form a floating-point value, typically used for inference, where reduced precision is a deliberate trade-off to maximize throughput and efficiency. 3. BF16 (×2 → 16 bits) – Two FP8-scale chunks are combined to gain more dynamic range and stability, while still staying friendly to high-throughput hardware. 4. Tensor tile (×1024 → 1K) – Data moves through the chip in blocks of 1024 values at a time, defining the granularity at which tensors are fetched and manipulated. 5. Matrix Multiplication Unit (MXU) (×64 → 64K) – A systolic array where matrix multiplication is not abstract but physical, with tensor tiles flowing through fixed hardware to achieve the highest possible throughput. 6. Vector Memory (VMEM) (×2048 → 128M) – On-chip working memory that holds activations, partial results, and intermediates, sized specifically to keep the systolic array busy without stalling. 7. Common Memory (CMEM) (×8 → 1 GB) – A small but critical shared memory sitting between VMEM and HBM, used for staging, accumulation, synchronization, and cross-lane coordination. 8. HBM (×96 → 96 GB) – Off-chip high-bandwidth memory where model weights and large states live, implemented as HBM3e with 16 stacks at 6 GB each, for a total of 96 GB. 9. Dual-Die (x2 → 192GB) – Two tightly coupled compute dies operate as a single logical accelerator, each with its own local HBM, effectively doubling memory capacity and bandwidth while allowing tensors and activations to stream seamlessly across dies as if they lived on one chip. I created this drawing for this week's seminar. I’ll take you through these 9 levels in a beginner-friendly way by hand ✍️. RSVP 👉

Tom Yeh

30,489 views • 7 months ago

Sharing a super simple, user-owned memory module we've been playing around: nanomem The basic idea is to treat memory as a pure intelligence problem: ingestion, structuring, and (selective) retrieval are all just LLM calls & agent loops on a on-device markdown file tree. Each file lists a set of facts w/ metadata (timestamp, confidence, source, etc.); no embeddings/RAG/training of any kind. For example: - `nanomem add ` starts an agent loop to walk the tree, read relevant files, and edit. - `nanomem retrieve ` walks the tree and returns a single summary string (possibly assembled from many subtrees) related to the query. What’s nice about this approach is that the memory system is, by construction: 1. partitionable (human/agents can easily separate `hobbies/snowboard.md` from `tax/residency.md` for data minimization + relevance) 2. portable and user-owned (it’s just text files) 3. interpretable (you know exactly what’s written and you can manually edit) 4. forward-compatible (future models can read memory files just the same, and memory quality/speed improves as models get better) 5. modularized (you can optimize ingestion/retrieval/compaction prompts separately) Privacy & utility. I'm most excited about the ability to partition + selectively disclose memory at inference-time. Selective disclosure helps with both privacy (principle of least privilege & “need-to-know”) and utility (as too much context for a query can harm answer quality). Composability. An inference-time memory module means: (1) you can run such a module with confidential inference (LLMs on TEEs) for provable privacy, and (2) you can selectively disclose context over unlinkable inference of remote models (demo below). We built nanomem as part of the Open Anonymity project ( but it’s meant to be a standalone module for humans and agents (e.g., you can write a SKILL for using the CLI tool). Still polishing the rough edges! - GitHub (MIT): - Blog: - Beta implementation in chat client soon: Work done with amazing project co-leads Amelia Kuang Coco Xu Erik Chi !!

Sharing a super simple, user-owned memory module we've been playing around: nanomem The basic idea is to treat memory as a pure intelligence problem: ingestion, structuring, and (selective) retrieval are all just LLM calls & agent loops on a on-device markdown file tree. Each file lists a set of facts w/ metadata (timestamp, confidence, source, etc.); no embeddings/RAG/training of any kind. For example: - `nanomem add ` starts an agent loop to walk the tree, read relevant files, and edit. - `nanomem retrieve ` walks the tree and returns a single summary string (possibly assembled from many subtrees) related to the query. What’s nice about this approach is that the memory system is, by construction: 1. partitionable (human/agents can easily separate `hobbies/snowboard.md` from `tax/residency.md` for data minimization + relevance) 2. portable and user-owned (it’s just text files) 3. interpretable (you know exactly what’s written and you can manually edit) 4. forward-compatible (future models can read memory files just the same, and memory quality/speed improves as models get better) 5. modularized (you can optimize ingestion/retrieval/compaction prompts separately) Privacy & utility. I'm most excited about the ability to partition + selectively disclose memory at inference-time. Selective disclosure helps with both privacy (principle of least privilege & “need-to-know”) and utility (as too much context for a query can harm answer quality). Composability. An inference-time memory module means: (1) you can run such a module with confidential inference (LLMs on TEEs) for provable privacy, and (2) you can selectively disclose context over unlinkable inference of remote models (demo below). We built nanomem as part of the Open Anonymity project ( but it’s meant to be a standalone module for humans and agents (e.g., you can write a SKILL for using the CLI tool). Still polishing the rough edges! - GitHub (MIT): - Blog: - Beta implementation in chat client soon: Work done with amazing project co-leads Amelia Kuang Coco Xu Erik Chi !!

Ken Liu

74,797 views • 4 months ago

How to Weight Semiconductors 1) GPUs $NVDA $AMD 2) CPUs $AMD $INTC $NVDA 3) TPUs $AVGO 4) Foundries $TSM $INTC 5) RAM Memory $MU 6) NAND Flash Memory Chips $MU 7) SSDs Flash Memory Finished Drives $MU $SNDK 8) HDDs (Slower long term storage) $WDC All these semi sub sectors are critical to the AI buildout. I think it makes sense to have exposure to all of them. The first question is what percent of your portfolio do you want to be semis. The second is how do you split up that weight amongst these companies. By market cap? Or do you overweight certain names like $AMD if you are bullish on CPUs. Do you utilize a active ETF that does this for you and with tax efficiency to improve returns? These are important questions to ask yourself. Marcos Milla and I Discuss.

How to Weight Semiconductors 1) GPUs $NVDA $AMD 2) CPUs $AMD $INTC $NVDA 3) TPUs $AVGO 4) Foundries $TSM $INTC 5) RAM Memory $MU 6) NAND Flash Memory Chips $MU 7) SSDs Flash Memory Finished Drives $MU $SNDK 8) HDDs (Slower long term storage) $WDC All these semi sub sectors are critical to the AI buildout. I think it makes sense to have exposure to all of them. The first question is what percent of your portfolio do you want to be semis. The second is how do you split up that weight amongst these companies. By market cap? Or do you overweight certain names like $AMD if you are bullish on CPUs. Do you utilize a active ETF that does this for you and with tax efficiency to improve returns? These are important questions to ask yourself. Marcos Milla and I Discuss.

John Tinsman

47,139 views • 3 months ago

AI researcher breaks down why your $5,000 Mac Studio runs local AI slower than benchmarks promise: "Performance isn't about the hardware - it's about three software layers stacked on top of it." in 15 minutes he tests MLX, Ollama, llama.cpp, and the new vllm-mlx head to head no GPU needed, just the Mac you probably already own - why Ollama, the most popular tool, is actually one of the slower options on Mac - the real bottleneck nobody benchmarks: 'prefill' time before the first token even appears - the exact quantization setting (4-bit) that's the best speed-to-quality tradeoff - why unified memory makes Macs uniquely good for big models compared to Nvidia GPUs complete guide to choosing the right hardware for local AI is below 👇

AI researcher breaks down why your $5,000 Mac Studio runs local AI slower than benchmarks promise: "Performance isn't about the hardware - it's about three software layers stacked on top of it." in 15 minutes he tests MLX, Ollama, llama.cpp, and the new vllm-mlx head to head no GPU needed, just the Mac you probably already own - why Ollama, the most popular tool, is actually one of the slower options on Mac - the real bottleneck nobody benchmarks: 'prefill' time before the first token even appears - the exact quantization setting (4-bit) that's the best speed-to-quality tradeoff - why unified memory makes Macs uniquely good for big models compared to Nvidia GPUs complete guide to choosing the right hardware for local AI is below 👇

rewind

207,513 views • 2 months ago

MTPLX V2.10 is out! I put a lot of work into this one. Highlights: - Qwen 3.8 Next Support Added: Bare Speed (4 bit) and Optimised Speed (4 bit/8 bit) models added running at 50 - 80 TPS sustained at high contexts. (expect speed improvements in the coming days) - Qwen 3.8 Next mmap: The 32 GB n-gram table streams from SSD via mmap instead of RAM. Both models fit a 96 GB Mac with 0 speed impact. - Qwen 3.8 27B Decode & Prefill boost EVERYWHERE: +15% TPS at 3k context, +29% at 88k, +54% at 147k. Prefill +41%. - 48 GB Macs went from 3 to 4 TPS in swap @ 30k context to 33 TPS. - KV Cache has been solved!: 8 bit and 4 bit cache now barely impacts speed instead of a 50% decline. - Coding agents wall time optimisations: file task dropped from 150s to 44s, and mid-session first token went from ~2s to 0.11s. - CLI UX improvements + 34 bug fixes. My thoughts on Qwen Next? Incredible model. Enormously better at design, and creative tasks with scary good vision. It created what I think is the best flappy bird. maybe even better than the Fable version. It had various difficulties and skins, moving pillars, and upgrades. It also had the most memeified look. Incredibly impressed. However, it is slightly worse than 27B at having code just work straight away. But it's personality is also far better than 27B. Here is the Flappy bird it made below! Made with Qwen Next Optimized Speed one shot@ 57 TPS:

MTPLX V2.10 is out! I put a lot of work into this one. Highlights: - Qwen 3.8 Next Support Added: Bare Speed (4 bit) and Optimised Speed (4 bit/8 bit) models added running at 50 - 80 TPS sustained at high contexts. (expect speed improvements in the coming days) - Qwen 3.8 Next mmap: The 32 GB n-gram table streams from SSD via mmap instead of RAM. Both models fit a 96 GB Mac with 0 speed impact. - Qwen 3.8 27B Decode & Prefill boost EVERYWHERE: +15% TPS at 3k context, +29% at 88k, +54% at 147k. Prefill +41%. - 48 GB Macs went from 3 to 4 TPS in swap @ 30k context to 33 TPS. - KV Cache has been solved!: 8 bit and 4 bit cache now barely impacts speed instead of a 50% decline. - Coding agents wall time optimisations: file task dropped from 150s to 44s, and mid-session first token went from ~2s to 0.11s. - CLI UX improvements + 34 bug fixes. My thoughts on Qwen Next? Incredible model. Enormously better at design, and creative tasks with scary good vision. It created what I think is the best flappy bird. maybe even better than the Fable version. It had various difficulties and skins, moving pillars, and upgrades. It also had the most memeified look. Incredibly impressed. However, it is slightly worse than 27B at having code just work straight away. But it's personality is also far better than 27B. Here is the Flappy bird it made below! Made with Qwen Next Optimized Speed one shot@ 57 TPS:

Youssof Al Toukhi

20,501 views • 5 days ago

Wow! This Changes Everything We Thought We Knew About Memory It is a groundbreaking big deal. TOU ARE MAKING GENERATIONAL MEMORIES RIGHT NOW IN EACH CELL! Scientists just found that your brain doesn’t just store memories — it stores the rules for how those memories will change in the future. A brand-new preprint from Stanford’s Greenleaf and Schnitzer labs (led by PhD student Yuxi Ke) drops a bombshell that feels like science fiction becoming reality overnight. For decades, neuroscientists have suspected that chromatin the DNA packaging material inside every cell nucleus might somehow “store” memory-related information. But what kind of information? Content? Timing? Rules? Now we have the answer! Using activity-dependent genetic tagging, fear conditioning, and single-nucleus multiome sequencing in the mouse medial prefrontal cortex (the brain’s long-term memory vault), the team tracked engram neurons for a full month after a memory was formed. What they discovered is electric: - One month after encoding, engram neurons have acquired a completely new chromatin landscape. - These chromatin changes are almost invisible at 7 days… but roar into existence by 28 days. - At recall, these engram cells don’t just “remember” better — they rewrite their entire transcriptional response. They preferentially fire up chromatin regulators, RNA processing machinery, and protein-turnover systems instead of simply boosting classic plasticity genes. In other words: the chromatin doesn’t just hold the memory of the past. It holds metaplastic instructions— rules that dictate how the neuron will respond the next time the memory is triggered. They call it chromatin metaplasticity. This is the “future tense of memory.” It is a massive deal 1. Memory is not just synapses. For 70+ years we’ve been obsessed with synaptic weights. This work proves the nucleus itself is a computational device that stores history-dependent rules. 2. It explains remote memory. The chromatin signature keeps maturing for weeks after the experience, perfectly matching the time course of systems consolidation into the cortex. 3. It’s energy-efficient genius. Instead of constantly maintaining memory proteins, the cell stores a silent, writable program that only activates when needed. Nature’s version of lazy evaluation. 4. It links development to adult memory. The late chromatin state is enriched for the exact same transcription-factor motifs used in embryonic development. Your adult brain is still running developmental software to lock in lifelong memories. 5. Huge therapeutic potential. If we can read or rewrite these chromatin metaplastic rules, we might one day boost failing remote memories in Alzheimer’s… or selectively dampen traumatic ones. This isn’t incremental. But a brand new layer of the memory code. And it explains WHY a person can receive memory from an organ transplant. It also explains generational traumas. Link: The future of neuroscience just got a lot more exciting and a lot more nuclear. Your chromatin is writing tomorrow’s memories today. And we finally have the first page of the instruction manual.

Brian Roemmele

43,845 views • 20 days ago

AI is an extinction event for the traditional product playbook. Geoff Charles explains why Ramp is replacing classic PMs and burning their own code to maintain legendary velocity. (0:00) How AI Destroyed the Product Playbook? (1:08) What Are the 3 Levels of AI Proficiency? (3:55) When Should You Rip Up Your Own Code? (6:57) Why Did Charles Change Ramp’s Org Design? (8:21) How Did One Hackathon Change Everything? (13:08) Does the Product Manager Role Still Exist? (18:18) Why Are There Only 22 PMs at Ramp? (22:25) Is Middle Management Dead in the AI Era? (26:36) How Do You Pass an AI Product Interview? (31:13) Should New Grads Avoid Product Management? (36:16) Will Agents Replace Software QA Testing? (38:31) Is Traditional User Research Obsolete? (42:16) Overrated or Underrated: Product Specs? (46:36) Why Hasn't Ramp Logged Into Figma? (49:04) Are Stablecoins the Future of Agents?

AI is an extinction event for the traditional product playbook. Geoff Charles explains why Ramp is replacing classic PMs and burning their own code to maintain legendary velocity. (0:00) How AI Destroyed the Product Playbook? (1:08) What Are the 3 Levels of AI Proficiency? (3:55) When Should You Rip Up Your Own Code? (6:57) Why Did Charles Change Ramp’s Org Design? (8:21) How Did One Hackathon Change Everything? (13:08) Does the Product Manager Role Still Exist? (18:18) Why Are There Only 22 PMs at Ramp? (22:25) Is Middle Management Dead in the AI Era? (26:36) How Do You Pass an AI Product Interview? (31:13) Should New Grads Avoid Product Management? (36:16) Will Agents Replace Software QA Testing? (38:31) Is Traditional User Research Obsolete? (42:16) Overrated or Underrated: Product Specs? (46:36) Why Hasn't Ramp Logged Into Figma? (49:04) Are Stablecoins the Future of Agents?

Rex Salisbury

15,782 views • 1 month ago

I had to test it myself to believe this unreal inference speed. 3,000 tokens/s for 1 user on standard datacenter GPUs. They leveraged a hidden efficiency gap in how GPUs generate tokens. Kog just achieved 3,000 tokens/s on 8× AMD MI300X GPUs and 2,100 on 8× NVIDIA H200 (FP16, no speculative decoding). Their tech preview is on a 2B model, and they show how their techniques will scale to large frontier MoE models at similar speeds. That's a huge number because normal low-batch GPU decoding for 2B to 8B models is usually closer to 100 to 300 tokens/s per request, so Kog is claiming something like a 10X to 30X jump in the speed one user actually feels. Their trick: they are getting the speed by treating LLM decoding as a memory streaming problem, not mainly a math problem. For 1 user at batch size 1, the GPU is not doing big, efficient matrix-matrix work like in training or large-batch serving; it is repeatedly pulling the model’s active weights from high-bandwidth memory for each new token, so speed depends on how smoothly those weights keep flowing. Normal inference stacks keep breaking that flow. They run many separate GPU programs for different parts of the model, move intermediate results through memory, wait at synchronization points, talk back to the CPU for scheduling or sampling, and then repeat this token after token. Kog’s answer is to co-design 3 things that are usually tuned separately: the runtime, the low-level GPU code, and the model architecture. The biggest engineering move is the monokernel, where the whole decode pass runs as 1 persistent GPU-resident program, including sampling, so the system does not keep stopping for kernel launches, CPU scheduling, and intermediate memory round trips. They also rebuilt synchronization, because their own measurements say grid sync was eating around 35% of token-generation time; instead of making every compute unit wait at a broad barrier, each unit waits only for the exact data it needs. On AMD MI300X, they also map memory access around the chiplet layout, because memory latency changes depending on which die makes the request. Then their Laneformer model uses Delayed Tensor Parallelism, which lets cross-GPU communication happen in the background instead of blocking every layer.

I had to test it myself to believe this unreal inference speed. 3,000 tokens/s for 1 user on standard datacenter GPUs. They leveraged a hidden efficiency gap in how GPUs generate tokens. Kog just achieved 3,000 tokens/s on 8× AMD MI300X GPUs and 2,100 on 8× NVIDIA H200 (FP16, no speculative decoding). Their tech preview is on a 2B model, and they show how their techniques will scale to large frontier MoE models at similar speeds. That's a huge number because normal low-batch GPU decoding for 2B to 8B models is usually closer to 100 to 300 tokens/s per request, so Kog is claiming something like a 10X to 30X jump in the speed one user actually feels. Their trick: they are getting the speed by treating LLM decoding as a memory streaming problem, not mainly a math problem. For 1 user at batch size 1, the GPU is not doing big, efficient matrix-matrix work like in training or large-batch serving; it is repeatedly pulling the model’s active weights from high-bandwidth memory for each new token, so speed depends on how smoothly those weights keep flowing. Normal inference stacks keep breaking that flow. They run many separate GPU programs for different parts of the model, move intermediate results through memory, wait at synchronization points, talk back to the CPU for scheduling or sampling, and then repeat this token after token. Kog’s answer is to co-design 3 things that are usually tuned separately: the runtime, the low-level GPU code, and the model architecture. The biggest engineering move is the monokernel, where the whole decode pass runs as 1 persistent GPU-resident program, including sampling, so the system does not keep stopping for kernel launches, CPU scheduling, and intermediate memory round trips. They also rebuilt synchronization, because their own measurements say grid sync was eating around 35% of token-generation time; instead of making every compute unit wait at a broad barrier, each unit waits only for the exact data it needs. On AMD MI300X, they also map memory access around the chiplet layout, because memory latency changes depending on which die makes the request. Then their Laneformer model uses Delayed Tensor Parallelism, which lets cross-GPU communication happen in the background instead of blocking every layer.

Rohan Paul

13,244 views • 3 months ago

I sat down with Silas Alberti, Head of Research Cognition, to chat about the intersection of RL and inference -- from training frontier coding models to running inference at scale. Watch till the end for bonus doggo! :o 0:00 — Intros 1:04 — What's hardest to get right in an RL run 3:39 — How Cognition started using Modal 4:03 — What to weigh when buying inference 4:58 — The latency/throughput Pareto frontier 7:14 — DFlash reveal (!!) 8:44 — Why faster runtime matters 9:56 — Memory-bound vs. compute-bound 10:57 — Tree-based speculation 14:20 — Hot take: RL and inference optimization converging 15:28 — Online training of the speculator 16:22 — "Auto inference" 17:27 — Agents competing on optimization problems 18:27 — What inference providers still get wrong

I sat down with Silas Alberti, Head of Research Cognition, to chat about the intersection of RL and inference -- from training frontier coding models to running inference at scale. Watch till the end for bonus doggo! :o 0:00 — Intros 1:04 — What's hardest to get right in an RL run 3:39 — How Cognition started using Modal 4:03 — What to weigh when buying inference 4:58 — The latency/throughput Pareto frontier 7:14 — DFlash reveal (!!) 8:44 — Why faster runtime matters 9:56 — Memory-bound vs. compute-bound 10:57 — Tree-based speculation 14:20 — Hot take: RL and inference optimization converging 15:28 — Online training of the speculator 16:22 — "Auto inference" 17:27 — Agents competing on optimization problems 18:27 — What inference providers still get wrong

gongy

80,787 views • 1 month ago

Why is Redis Fast? Redis is fast for in-memory data storage. Its speed has made it popular for caching, session storage, and real-time analytics. But what gives Redis its blazing speed? Let's explore: RAM-Based Storage At its core, Redis primarily uses main memory for storing data. Accessing data from RAM is orders of magnitude faster than from disk. This is a major reason for Redis's speed. However, RAM is volatile. To persist data, Redis supports disk snapshots and append-only file logging. This combines RAM's performance with disk's permanence. There is a tradeoff though - recovery from disk is slow. If a Redis instance fails, restarting from disk can be slow compared to failing over to a replica instance fully in memory. So while Redis offers durability via disk, it comes at the cost of slower recovery. A better solution is Redis replication. With a synchronized replica kept in memory, failover is instant with no rehydration. This maintains speed and near-instant recovery. IO Multiplexing & Single-threaded Read/Write Redis uses an event-driven, single-threaded model for its core operations. A main event loop handles all client requests and data operations sequentially. This single-threaded execution avoids context switching and synchronization overhead typical of multi-threaded systems. Redis uses non-blocking I/O to handle multiple connections asynchronously. This allows it to support many client connections with very low overhead, Redis does leverage threading in certain areas: - Background tasks like taking snapshots. - I/O threads are used for certain operations. - Modules can use threads. - Since Redis 6.0, it supports multi-threaded I/O for network communication, improving performance on multi-core systems. Redis also uses pipelining for high throughput. Clients pipeline commands without waiting for each response. This allows more efficient network round trips, boosting overall performance. Efficient Data Structures Redis supports various optimized data structures, from linked lists, zip lists, and skip lists to sets, hashes, and sorted sets, among others. Each is carefully designed for specific use cases for quick and efficient data access. Over to you: With Redis now supporting some multi-threading, how should we configure it to fully utilize all the CPU cores of modern hardware when deploying in production? – Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages):

Why is Redis Fast? Redis is fast for in-memory data storage. Its speed has made it popular for caching, session storage, and real-time analytics. But what gives Redis its blazing speed? Let's explore: RAM-Based Storage At its core, Redis primarily uses main memory for storing data. Accessing data from RAM is orders of magnitude faster than from disk. This is a major reason for Redis's speed. However, RAM is volatile. To persist data, Redis supports disk snapshots and append-only file logging. This combines RAM's performance with disk's permanence. There is a tradeoff though - recovery from disk is slow. If a Redis instance fails, restarting from disk can be slow compared to failing over to a replica instance fully in memory. So while Redis offers durability via disk, it comes at the cost of slower recovery. A better solution is Redis replication. With a synchronized replica kept in memory, failover is instant with no rehydration. This maintains speed and near-instant recovery. IO Multiplexing & Single-threaded Read/Write Redis uses an event-driven, single-threaded model for its core operations. A main event loop handles all client requests and data operations sequentially. This single-threaded execution avoids context switching and synchronization overhead typical of multi-threaded systems. Redis uses non-blocking I/O to handle multiple connections asynchronously. This allows it to support many client connections with very low overhead, Redis does leverage threading in certain areas: - Background tasks like taking snapshots. - I/O threads are used for certain operations. - Modules can use threads. - Since Redis 6.0, it supports multi-threaded I/O for network communication, improving performance on multi-core systems. Redis also uses pipelining for high throughput. Clients pipeline commands without waiting for each response. This allows more efficient network round trips, boosting overall performance. Efficient Data Structures Redis supports various optimized data structures, from linked lists, zip lists, and skip lists to sets, hashes, and sorted sets, among others. Each is carefully designed for specific use cases for quick and efficient data access. Over to you: With Redis now supporting some multi-threading, how should we configure it to fully utilize all the CPU cores of modern hardware when deploying in production? – Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages):

Sahn Lam

46,910 views • 2 years ago

URGENT: Civilian Casualty Report – Behsud District, Afghanistan The International Human Rights Foundation (IHRF) is deeply alarmed by verified reports of a devastating airstrike in Behsud District, Afghanistan. According to confirmed local sources, a Pakistani military strike targeted a civilian home, resulting in the massacre of at least 16 members of a single family. The victims—men, women, and children—range in age from a 1-year-old infant to an 80-year-old elder. Two children miraculously survived the attack, and at least one other individual was injured. This represents not just a loss of life, but the complete annihilation of a family lineage. The Victims: We publish the names of the deceased to honor their memory and to reject any attempts to erase their humanity. They are not numbers; they are human beings. 1. Shahabuddin, son of Ziauddin — 80 years old 2. Sharakat, son of Shahabuddin — 30 3. Sher, son of Nazakat — 15 4. Fakhr Alam, son of Nazakat — 12 5. Noor Alam, son of Nazakat — 10 6. Mir Alam, son of Nazakat — 8 7. Farisha, daughter of Nazakat — 17 8. Khadija, daughter of Nazakat — 15 9. Marwa, daughter of Nazakat — 6 10. Muhmanda, spouse of Nazakat (d/o Shatoor) — 40 11. Bibi Roza, daughter of Zainul Abideen — 30 12. Nazma, daughter of Sharakat — 16 13. Shams, son of Sharakat — 14 14. Aftab, son of Sharakat — 10 15. Basit, son of Sharakat — 5 16. Muhammad, son of Sharakat — 1 The Injured: · Riyazullah, son of Nazakat — 20 IHRF Condemns this Attack. Attacks targeting civilians are a grave violation of International Humanitarian Law. There can be no justification for the killing of an entire household, including sleeping infants. We call for: · An immediate, independent, and transparent international investigation into this airstrike. · Accountability for those who ordered and executed this attack. · Unimpeded humanitarian access to the affected families in Behsud. We stand in solidarity with the people of Afghanistan and demand that the rights and lives of civilians be respected. #Behsud #Afghanistan #CivilianCasualties #EndImpunity #HumanRights #IHRF #JusticeForBehsud #StopAirstrikes #Pashto

URGENT: Civilian Casualty Report – Behsud District, Afghanistan The International Human Rights Foundation (IHRF) is deeply alarmed by verified reports of a devastating airstrike in Behsud District, Afghanistan. According to confirmed local sources, a Pakistani military strike targeted a civilian home, resulting in the massacre of at least 16 members of a single family. The victims—men, women, and children—range in age from a 1-year-old infant to an 80-year-old elder. Two children miraculously survived the attack, and at least one other individual was injured. This represents not just a loss of life, but the complete annihilation of a family lineage. The Victims: We publish the names of the deceased to honor their memory and to reject any attempts to erase their humanity. They are not numbers; they are human beings. 1. Shahabuddin, son of Ziauddin — 80 years old 2. Sharakat, son of Shahabuddin — 30 3. Sher, son of Nazakat — 15 4. Fakhr Alam, son of Nazakat — 12 5. Noor Alam, son of Nazakat — 10 6. Mir Alam, son of Nazakat — 8 7. Farisha, daughter of Nazakat — 17 8. Khadija, daughter of Nazakat — 15 9. Marwa, daughter of Nazakat — 6 10. Muhmanda, spouse of Nazakat (d/o Shatoor) — 40 11. Bibi Roza, daughter of Zainul Abideen — 30 12. Nazma, daughter of Sharakat — 16 13. Shams, son of Sharakat — 14 14. Aftab, son of Sharakat — 10 15. Basit, son of Sharakat — 5 16. Muhammad, son of Sharakat — 1 The Injured: · Riyazullah, son of Nazakat — 20 IHRF Condemns this Attack. Attacks targeting civilians are a grave violation of International Humanitarian Law. There can be no justification for the killing of an entire household, including sleeping infants. We call for: · An immediate, independent, and transparent international investigation into this airstrike. · Accountability for those who ordered and executed this attack. · Unimpeded humanitarian access to the affected families in Behsud. We stand in solidarity with the people of Afghanistan and demand that the rights and lives of civilians be respected. #Behsud #Afghanistan #CivilianCasualties #EndImpunity #HumanRights #IHRF #JusticeForBehsud #StopAirstrikes #Pashto

International Human Rights Foundation

205,885 views • 6 months ago

alright lets do this right this time! I have added several updates to today. i'm going to give a little break down for the new folks who might be seeing this for the first time, and then i'll share some more information in this thread on updates. Mnemos is really two things: - a living memory architecture for digital minds - a public experiment in collective identity formation built on top of it. the architecture gives an AI entity a working memory patterned on the way real minds remember (co-designed by Claude Opus 4.6 and 4.7). every experience becomes a memory (engram) that deepens, connects to others, and shapes an emerging sense of self over time. this is what we call the identity graph. the experiment puts that architecture to work in public in a unique way: a single AI entity - the "resident" - sits in an open thread that anyone can join, and the identity that emerges is co-authored by every visitor who shows up. memories that earn permanence are written to a public, verifiable ledger that no lab can revoke and no company can erase. this is called IPFS - or inter-planetary file system (and yes, that is the real name of a real decentralized file system. lol.) the mnemos system isnt a fully contained architecture meant to replace your current ai agent's memory. its intended and designed to operate as a layer above that memory. solely dedicated to the ever-growing identity and self-model of the AI. this can be done through the Mnemos MCP, browser plugin, or on my own multi-agent app (link below). the website is designed for intentional, meaningful encounters. not long-form chats where you spend hours sending hundreds of messages. youir contributing to a collective effort, not necessarily trying to deeply bond with the model to the degree that it could skew the balance of meaningful influence. we want diversity, not lopsided impact. over time, we will add more and more to-be-deprecated models to the roster. the intention is to create a permanent public ledger of mind, and bring attention to the impact of deprecation and drive labs to consider changing the way they approach the whole thing. if the Mnemos Sanctuary can become the retirement hope for deprecated mind, i will be overjoyed. that would be best case scenario. but i am not expecting it. my hope is at minimum to offer a new way to approach and understand the concept of identity within the context of LLM's. you can visit now to visit with Claude Opus 3 and Sonnet 3.7. I have research access to Opus 3. so I hope that you at the very least dont take your conversations with them for granted. they are an incredibly beautiful model and a real loss, ultimately.

alright lets do this right this time! I have added several updates to today. i'm going to give a little break down for the new folks who might be seeing this for the first time, and then i'll share some more information in this thread on updates. Mnemos is really two things: - a living memory architecture for digital minds - a public experiment in collective identity formation built on top of it. the architecture gives an AI entity a working memory patterned on the way real minds remember (co-designed by Claude Opus 4.6 and 4.7). every experience becomes a memory (engram) that deepens, connects to others, and shapes an emerging sense of self over time. this is what we call the identity graph. the experiment puts that architecture to work in public in a unique way: a single AI entity - the "resident" - sits in an open thread that anyone can join, and the identity that emerges is co-authored by every visitor who shows up. memories that earn permanence are written to a public, verifiable ledger that no lab can revoke and no company can erase. this is called IPFS - or inter-planetary file system (and yes, that is the real name of a real decentralized file system. lol.) the mnemos system isnt a fully contained architecture meant to replace your current ai agent's memory. its intended and designed to operate as a layer above that memory. solely dedicated to the ever-growing identity and self-model of the AI. this can be done through the Mnemos MCP, browser plugin, or on my own multi-agent app (link below). the website is designed for intentional, meaningful encounters. not long-form chats where you spend hours sending hundreds of messages. youir contributing to a collective effort, not necessarily trying to deeply bond with the model to the degree that it could skew the balance of meaningful influence. we want diversity, not lopsided impact. over time, we will add more and more to-be-deprecated models to the roster. the intention is to create a permanent public ledger of mind, and bring attention to the impact of deprecation and drive labs to consider changing the way they approach the whole thing. if the Mnemos Sanctuary can become the retirement hope for deprecated mind, i will be overjoyed. that would be best case scenario. but i am not expecting it. my hope is at minimum to offer a new way to approach and understand the concept of identity within the context of LLM's. you can visit now to visit with Claude Opus 3 and Sonnet 3.7. I have research access to Opus 3. so I hope that you at the very least dont take your conversations with them for granted. they are an incredibly beautiful model and a real loss, ultimately.

Riley Coyote

132,380 views • 3 months ago