Local AI's biggest problem, and the wireless GPU that claims to solve it
A sponsored hands-on test of WiCi One, a box that shares one RTX 5090 over Wi-Fi and runs a 750 billion parameter model off an SSD.
Posted
4 days ago
Duration
Format
Review
hype
Views
751.3K
13.1K likes
57 · 43
Big Idea
The argument in one line.
Local AI's two hard limits, a GPU that can't be shared and models too big for VRAM, can be worked around with smarter data movement instead of more hardware.
Who This Is For
Read if. Skip if.
READ IF YOU ARE…
You run or want to run local AI models and keep hitting the wall of VRAM that is too small for the models you actually want.
You want a plain-English explanation of mixture-of-experts models and why SSD speed becomes the bottleneck when a model doesn't fit in memory.
You're weighing whether one shared GPU for a whole household or small office makes sense versus buying a GPU per machine.
SKIP IF…
You want an independent review: the video is sponsored by WiCi and every number comes from one early engineering unit.
You only use cloud AI tools and have no interest in how local inference works.
TL;DR
The full version, fast.
NetworkChuck tests WiCi One, a box with an RTX 5090 that laptops and Macs use over Wi-Fi as if it were installed locally. A fake driver convinces the OS the GPU is real, and a custom protocol bundles, compresses and pre-answers traffic so the link needs about 400 Mbps instead of 8 Gbps. For local AI, the box runs the 750 billion parameter DeepSeek V4.1 Flash by keeping the full model on a 4 TB SSD, aligning expert weights into chunks, caching popular experts in VRAM and RAM, and splitting math between CPU and GPU. He reports roughly 8 to 15 tokens per second and faster model switching through a scheduler that parks models on the SSD.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Cold open: Cyberpunk, Blender and DeepSeek all running on a remote RTX 5090 that devices treat as their own.
00:38 – 02:15
02 · What WiCi One is
Sponsor disclosure, unboxing of the early engineering model, and the 'family GPU' idea.
02:15 – 04:37
03 · Why Wi-Fi should be too slow
PCIe versus Wi-Fi bandwidth and round trip time, and how WiCi's fake driver and protocol close the gap.
04:37 – 06:05
04 · From cloud gaming to wireless GPU
The 8 Gbps to 400 Mbps result, and the Tencent cloud gaming roots of the team.
06:05 – 07:32
05 · Two problems holding local AI back
Sets up GPUs not sharing and models not fitting, then jumps ahead to the big-model problem.
07:32 – 09:57
06 · Why frontier models don't fit at home
Over 500 GB of memory needed, and the memory speed ladder of VRAM, RAM and SSD.
09:57 – 11:59
07 · The math on 750 billion parameters
Tokens per second in the dream case versus a real SSD, down to minutes per word.
11:59 – 13:50
08 · Mixture of experts explained
Routers, 384 experts and top-6 selection, using a badminton question.
13:50 – 15:36
09 · The four tricks
Aligned chunks, 64-way reads, hot experts in VRAM and RAM, and CPU/GPU math split.
15:36 – 17:36
10 · DeepSeek running live
The expert visualizer, live tokens per second, and SSD read rates.
17:36 – 19:41
11 · Why GPUs don't share
Switching between image, video and chat models flushes VRAM; WiCi's scheduler parks models on the SSD.
19:41 – 21:06
12 · Testing the scheduler
Side-by-side switching times with and without the scheduler.
21:06 – 22:18
13 · Verdict, pricing, shipping
Early engineering model caveat, two editions, roughly eight weeks to ship.
22:18 – 23:36
14 · Closing prayer
Personal sign-off for the audience.
Atomic Insights
Lines worth screenshotting.
PCIe answers GPU requests in under a microsecond while Wi-Fi takes about 1.5 milliseconds, so a one-second PCIe task becomes about 25 minutes on Wi-Fi.
WiCi cut the bandwidth a Wi-Fi GPU needs from roughly 8 gigabits per second to 400 megabits per second by sending less and waiting less.
A fake GPU driver makes games and apps treat a remote RTX 5090 as local hardware, so nothing has to be rewritten for it.
This is not cloud gaming or remote desktop: the game still runs on the laptop and only the GPU work happens on the remote box.
Running DeepSeek V4.1 Flash at full quality needs over 500 GB of memory, which no consumer GPU or gaming PC has.
SSD bandwidth looks like 14 GB/s on paper, but millions of tiny 4 KB reads per token drop the real figure to roughly 1 to 5 gigabits per second.
Mixture-of-experts models only activate a few experts per token (6 of 384 here), but you can't predict which ones, so the whole model must stay reachable.
Re-laying out expert weights into same-size aligned chunks and reading 64 at a time raised SSD throughput from about 1 GB/s to 11.5 GB/s.
Keeping the most popular experts in VRAM and RAM means only about 1 GB per token has to come off the SSD.
GPUs were never designed to share, and switching between an image, video and chat model means flushing up to 32 GB of VRAM each time.
Parking idle models on the SSD cut a chat-to-image switch from about 18 seconds to 8.6 seconds and image-to-chat from 17 seconds to about 4 in the demo.
The same mixture-of-experts design that makes DeepSeek, Kimi and GLM cheap to run is what makes SSD-backed inference feasible at all.
Takeaway
Move less data, not more hardware
WHAT TO LEARN
Both of the video's big results come from sending fewer bytes in smarter ways, not from faster links or bigger memory.
For latency-bound workloads like GPUs, round trip time matters more than bandwidth, so removing waits beats widening the pipe.
Software can hide where hardware lives: a fake driver lets unmodified games and apps use a remote GPU as if it were local.
A model that is too big for VRAM can still run if you know which parts are hot and keep those close.
Mixture-of-experts models activate only a few experts per token, which is why open models like DeepSeek, Kimi and GLM are the ones that can be streamed from disk.
Quoted SSD speeds assume large sequential reads, and millions of tiny reads per token can drop real throughput by an order of magnitude.
Sharing one GPU across apps is mostly a model-swapping problem, and parking idle models on fast storage cuts switch times roughly in half or better.
Treat sponsored demos as one data point: this is a single early engineering unit with results that vary run to run, such as 15 tokens per second dropping to 3 to 4.
Glossary
Terms worth knowing.
WiCi One
The sponsor's wireless GPU box. It holds an RTX 5090 (or 5060 Ti), a mini PC, and a 4 TB SSD, and shares the GPU with other devices over Wi-Fi.
Round trip time
How long a request takes to get an answer back. For GPUs it matters more than raw bandwidth because games and models send thousands of small requests every second.
Mixture of experts (MoE)
A model design split into many specialist sub-networks. A router picks a few experts per token, so only a fraction of the parameters is used for each word.
VRAM
The fast memory on a graphics card. It is far faster than system RAM or an SSD but limited on consumer cards, here 32 GB on the RTX 5090.
Token
The chunk of text, roughly a word, that a language model generates one at a time. Tokens per second is the usual speed measure.
InferSSD
WiCi's open-source engine for running models larger than VRAM by streaming weights from an SSD.
OpenWRT
An open-source router operating system. The WiCi box runs it for its networking, which is how it appears on the home network.
plain-language framing of a technical limit→ newsletter pull-quote↗ Tweet quote
The Script
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
17px
This is the first Wi -Fi GPU running in NVIDIA 5090, and it's somehow over Wi -Fi showing up as this laptop's GPU. I'm playing Cyberpunk on it right now. Also, I'm running Blender on it.
But that's not even the craziest thing it's doing. Over here, I have a Mac also using the GPU. Not only is it generating images and videos very fast, all local AI, but it's also talking to this, DeepSeek 4 .1 Flash, a 750 billion parameter model running at full quality on a box with 32 gigabytes of VRAM.
This doesn't make any sense. You would normally need over 500 gigabytes of memory to run this. It's called WISI, Wireless Computing Infrastructure.
Get your coffee ready. I cannot wait to show you how it's doing all of this. Now let's get this right out in front.
This video is sponsored by Y site, but don't let that deter you. I heavily vet every sponsor and product I look at this one is crazy, which is why I said yes. And here, here we are.
They are a new company and they're doing something pretty bold. And when they told me about this thing claiming to be the first wireless GPU and it can run trillion parameter models, I had to try it like really does this thing work? And in this video, we will be trying everything, video editing, gaming, and impossible local AI inference with image and video generation.
Like it really doesn't make any sense what it's doing. And when I got it, like when it arrived, it was inside a suitcase inside a box full of bubble wrap. That's how new this thing is.
And here it is an early engineering model inside this box is an Nvidia RTX 50 90. There's also a mini PC as well. And it's actually running open WRT for its networking.
That's how it shows up on my network. Now, if I get brave enough, I will. undo this thing.
So if you're seeing that B roll now, I did it, but I'm gonna save it for the end of the video. So I don't break it before I make this content. Now the big idea with this thing is local, no cloud, right?
I'm already sold, but they taken it a step further, a step that I didn't think I wanted to take. This isn't just one device with a crazy powerful GPU. Like I already have that in my studio.
Instead, they just have the crazy GPU that multiple devices can use. Think about that. It's like a family GPU.
Kind of like how we used to have one family computer for everyone. Yes, that was a thing comment below if you had one family computer. So the idea is that if you have a laptop, a tablet, a phone, it can now use this desktop class GPU, like it's its own.
And it's not just throwing a job over to it. It's actually using it like playing cyberpunk on this little bitty laptop really hits at home for proof. You can actually hear the jet engine over here taking off.
This thing's taken off. And seeing that 50 90 show up in the task manager, like it belongs to that laptop is so weird and kind of wonderful. How are they doing this?
Let's actually hit that first, because there are two things that were breaking my brain and I have to figure it out. How are they doing this over wifi? Because wifi is not the greatest connection.
And how is this laptop suddenly believing that it has a 50 90 and we'll get to the whole trillion parameter model thing later. Now this will honestly be the craziest part of this video. I even built this visualizer that will show you exactly what's happening with the model on that GPU.
Now, by the way, have you hacked the YouTube algorithm today? Let's make sure you do hit that light button, subscribe notification bell comment. You gotta hack YouTube today.
Ethically. Of. Okay.
So let's talk about your GPU. Typically your GPU, your gaming GPU needs a very, very fast way of talking to your PC. And it does.
Here's our fun little 50 90 flying around. Can you keep an eye on it? It's fast.
When you slot that sucker into your gaming PC, this is gonna be your gaming PC right here. You're putting that into the PCIe port. This sucker's 512 gigabits per second answering requests in under a microsecond.
Now let's get this gaming PC outta here. We're using a laptop now. Now over wifi, instead of PCIe, we're talking about one gigabit per second, answering it around 1 .5 milliseconds.
And that's under the best conditions. Cuz wifi is kind of, you know, blah. And that is the technical term.
Now don't miss this. It's this right here, this round trip time, the time it takes to answer those requests that becomes a huge problem. And it actually might not seem that bad at first, right?
Like 1 .5 milliseconds. That's super fast. No, it's not.
If you compare that to a microsecond, I'll give you an analogy that helped my brain process this. If PCI handed you a picture in one second with wifi, that would take 25 minutes. And that's a big problem because the game and the GPU They're pretty chatty.
They're sending instructions and data and answers to create a frame thousands of times every second. If every one of those answers had to wait on wifi, we'd be playing with PowerPoint, but we're not look at this 92 frames per second over wifi. And I'm rendering this in blender.
And this is not remote desktop. It's running on this laptop on this GPU over wifi. How did Y size solve it?
Well, they created their own protocol. The team at Y side has a networking background. So that tracks.
The first thing they had to do is convince this laptop that he has a real GPU. that he's actually using this 50 90 over here. Like this is your real GPU buddy, even though you have no room for it.
They did that by installing a fake driver and what's crazy is cyberpunk. The game treats this GPU. Like it's right there.
Like it's the real one. It does not know the difference. Cool.
But they still didn't solve the problem of goodness. This right here is super slow. This communication.
So what they did was kind of. genius they just told them to stop talking so much like literally that's what they did they figured out which messages actually need answers and then stopped waiting on the rest for instructions they bundled them compressed them and sent them without waiting so for data it only sends what's changed and doesn't keep repeating itself for answers it doesn't even wait for the question it knows what's going to be asked so it just sends it this is the wi -fi version of that meeting could have been an email and then the gpu sends compressed video back to the laptop these four things they did took what would actually need to be like eight gigabits per second needed to now.
All they need is 400 megabits per second. Proof is in the pudding right now. We are gaming at 92 frames per second.
Look at the wifi right now. It's about 400 megabits per second going across and get this out of your brain. This ain't cloud gaming.
This also isn't remote desktop. The game isn't being streamed to us from the cloud. The game is still happening right there on the laptop.
but it's using the GPU over there over wifi, which is just the craziest thing to say. That was funny as some of the team at YSI actually used to work in cloud gaming. I work in the cloud gaming team in Tencent before.
And it was around the time that game, uh, Black Myth Wukong, I think that's how you say it, came out that they had this idea, the YSI idea. At a moment of Black Myth, we were thinking, can we still leave the front end on the laptop, but push back end to a remote place. That's where we started.
But then they discovered something kind of cool. Okay. Later on, we found that AI has a way more scenarios than gaming.
Okay. This is the part that got me most excited. When I first heard about YSI sure the wifi gaming is neat, but local AI, that's where things are happening.
That's where I'm most excited about everything. And this is legit a new way to approach using big models with local AI. So YSI actually did two things solve two big problems with local AI.
I think they might be a game changer. Prove me wrong in the comments.
Do it. And some of this might be news to you because I'm not like a GPU expert. I don't study this stuff, but I did on this video.
By the way, these videos take a minute because when someone sends me a product like this, I don't just go, neat, here are the talking points. No, like I actually get into it. I learn the technology.
I learn how it works so I can pass this along. And when it's something that I think is interesting, I do wanna pass it along. I get excited.
So the two things that you actually solve or two problems that exist one, you're already familiar with, but this first one, you're probably not GPUs. Don't like to share what we'll cover that here in a moment. And two, this is the obvious one.
Consumer GPUs can't run big models because they don't fit. They don't have enough memory. And yeah, they solve that.
So for the first one, GPUs don't like to share. What does that mean? I mean, sure.
This 50 90 is great at running local AI. Have you tried it?
It's fast. Hold up Chuck from the future here. I'm going to do a quick edit on this video for you because right here, I started to talk about how the GPU doesn't share, but I cannot wait for you to see the local AI stuff.
So I'm going to move that right over to now. I just want you to see it. And also I want you to see that visualizer I made.
It's so sick. It's like looking in the brain of deep seek. Here you go.
So again, our premise is that you can't run large AI models at home consumer GPUs, like the one inside this box, just don't have enough memory to run them yet. This box can how let's break it down. Now, first local AI is in a fun space right now.
You can run a ton of amazing models on pretty much any hardware and you can do some cool things. But when we're talking about the smart ones, the frontier like ones that get close to what you might experience with Opus 5 .5 or GPT six. And there are local models that are like that, like Kimmy K three or GLM 5 .3 or deep seek 4 .1.
These local models do give you a level of intelligence. That's pretty dang close to these frontier models. And the best part is that it's unlimited and it's free and it's yours.
Sounds great. Right? Yeah.
Well you can't do it. Normal people can't run this stuff. It requires a lot of memory, like a data center level of memory.
And have you seen the price of memory? The model I wanna focus on right now is the DeepSeek 4 .1 Flash. To run this sucker full quality, you need over 500 gigabytes of memory.
There is nothing consumer level that can do that. No GPU, no gaming PC that can support that much system memory. Even the new M5 Mac studios with 512 gigabytes of RAM can't really run this comfortably.
So again, How can this thing run it? Because we're not using memory.
We're using the SSD because inside this box right now is a four terabyte SSD and it's using it like memory. Now by the numbers, this is a terrible idea. It's such a bad idea.
Why are they doing this? Sure. SSDs.
They give us more capacity. You most likely can buy a four terabyte SSD. How much are they right now?
Field trip, four terabyte SSD on new egg. it's gonna cost us 500 bucks. So capacity we're getting that, but speed we're losing.
And that's our main problem right now. And you need speed when working with AI, let me show you what I'm talking about and how bad it normally would be with an SSD. If we didn't have what Y side was doing and what they're doing is pretty sick.
So just for a comparison, like what we're talking about, cuz there are different types of memory. I keep throwing them around memory, VRAM, which is the RAM that you're gonna see inside your When we're talking about the 50 90, we're gonna be around 1 .8 terabytes per second, wicked fast standard system, RAM, most modern stuff, DDR five 90 gigabytes per second.
And then we get down to the SSD 14 gigabytes per second. So if VRAM hands you a page in one second, RAM will take 20 seconds. The SSD will take Two minutes.
It's like that sloth from Zootopia. How does YSI deal with this? First, I want you to imagine the best scenario possible.
Imagine that somehow this 5090 has 550 gigabytes of VRAM. Can you imagine? No, you can't, but we're gonna do it right now with that.
We can run the full deep seek 4 .1 flash with 500 gigabytes of required Ram. It also has 750 billion parameters, pretty smart dude. And in this dream situation, speed is our ally for every word or token that this deep seek LLM generates.
It has to transfer all 750 billion parameters to the chip. This equates to roughly about 508 gigabytes.
This transfer right here, that's 1 .8 terabytes per second. That's given us 3 .5 words or tokens per second. That's great.
But if we face reality and we get real sad, we have to realize we can't run a model that size purely on a GPU. And we have to put it on the much, much, much, much, much, much, much slower SSD. Let's play that out.
so goodbye 550 we now are back to 32. by the way this is actually going to be worse than you think watch so we can actually still use the gpu in this measly 32 gigabytes but we still have to put 475 gigabytes of these parameters of these weights onto ssd and again for every single stinking word we have to transfer all the weights from the ssd to the CPU.
Now I know all you nerds in the comments, you're gonna go, actually, Chuck is supposed to go to the Ram first and then to the CPU. And I know, but just for simplicity, we're just gonna remove that step. Okay.
So for one word, we transfer it, it spits it out. What's the damage we might think, well, Chuck, we're getting 14 gigabytes per second, right? No, no, we're not.
We're not even getting that. This is the rated speed for large transfers. What SSDs are meant for at least hundreds of What's actually happening is the transfers here are small, lots of tiny transfers, four kilobytes, millions of tiny four kilobyte transfers per word per token.
So we're actually getting more around one to five gigabits per second, which means at its worst, Oh, we're getting eight minutes per word. Yeah, unusable, right?
But I know what you're doing. I can see you typing in the comments right now. You're about to type, well, Chuck, actually DeepSeek 4 .1 Flash is a mixture of experts model.
So we'll actually be faster. You know what? You're right.
Deep seek 4 .1 flash is not one of those dense models where every parameter is used for every word or token. It's an MOE model or mixture of experts model where only some of the parameters are used for every word or token, by the way, most of the best local open source models are mixture of experts. like Kimmy K three Quinn GLM.
And it does that by dividing the model up into experts. This one has 384 experts and kind of imagine each one being good at something like a few might be really good at answering questions about badminton. I don't know.
It's not quite like that, but it, it's gonna help illustrate it. So if you asked her a question, like what the junk is badminton, the model actually has a router built in. So let me actually draw this out.
It's kind of fun. It has a router built in and out of the 384 experts, it will choose the top six that are really good at answering questions about badminton and they will be used to generate the next word.
Now this is amazing because well, watch this. With only six experts being used, we only need around 15 gigabytes of weights and files to be transferred for each word instead of the massive 508 gigabytes. So in our fictional world where we could put the entire model on one GPU and it had 550 gigabytes of VRAM things would scream with that MOE model.
We're talking eight milliseconds per word, but in the real world with an SSD at its worst, it might be around 15 seconds per word better, but it still sucks. And there's no getting around this because even if we are only using six experts to generate the next word, You might think, oh, we just put all those six experts on the GPU.
It'll be fast. No, we don't know which six are gonna be chosen for each word. So we have to store the entire model.
So finally we're at what Y side is doing to make this manageable, make it work. And it's actually pretty sick. And by the way, you made it to this.
Think about that for a second. you learned a lot. Just now you learned that file transfer speed is actually really important for LLMs.
And it's kind of our main bottleneck right now. You learn what a mixture of experts model is and why it's kind of awesome for local AI. Now learn this why side did four things.
First, they rewrote the model files for the SSD drive so that every expert is the same size aligned chunks, which sounds gross, but it is good thing by the way, if you call me chunk in the comments, I forgive you, but it happens often. And now that I said that I know my editors are gonna have a lot of fun with it. with these chunks aligned.
They now speed up the transfer, reading it 64 chunks at a time. I've been saying chunk too much. Also pretend these are 64 chunks.
Having too much fun with this. They essentially optimize the model file so the SSD can transfer them faster. And now that everything's chunky, sorry, we've gone from one gigabyte per second to around 11 .5 gigabytes per second.
That's a huge jump. but we're not done yet. Remember how those six experts are chosen by the router for every word Y side keeps the most popular ones sitting on VRAM and RAM.
So if most of the experts that are gonna be generating the words are coming off VRAM and RAM with this design, only around one gigabyte worth of experts is being pulled from the SSD. So even though it is the slowest thing and they've, they've done their job to speed it up. We don't have to worry about this much.
And lastly, they split the math. If the weights are coming off the SSD or RAM, the CPU is gonna handle it. But if the weights are coming off VRAM, the GPU is gonna handle it.
With these four optimizations, let's see what actually happens. How fast is it? I'm gonna run some deep seek, y 'all.
It's getting really hot in here with my gaming machine and this bad boy keeping me toasty. Okay, time to test this sucker. Now, a couple things are happening right now.
I didn't think I could do this. This is actually pretty sick. What you're seeing on the screen right now is a way for us to visualize what's happening when we're talking to deep seek on this GPU.
We can see what's on SSD, on RAM, GPU, and watching the experts be chosen. Hey, Chuck from the future again. I just realized I did not tell you what this thing is actually doing.
It's not just some fancy graphic. I'm actually running this off of that wireless GPU. And we're actually looking into the brain of deep seek and how it's being used on the GPU and the SSD and the Ram and the VRAM.
It's actually watching it pick the experts. And I did this by looking at trace logs. It's a whole thing, but it's running live.
And it's awesome. Anyways, I just had to say that. Now, one thing you might be like, uh, Chuck, that doesn't make any sense.
It says all 508 gigabytes or 15 ,360 experts live here. Wait, Chuck, you said there's only 384 experts. Yes, but that's per layer.
I simplified it in the explanation, but the principle still stands. Now I'm recording also on this Mac, which is wirelessly connected to this GPU. Let's load up deep seek, ready, set load.
Oh, we can see stuff happening. Look at that. Whoa, look at it go.
This is pretty sick. It's ready. How is coffee roasted?
Explain that process. Oh, look at that. Whoa.
Look at all the experts being chosen. Notice most of them are coming from the GPU dude. And we're getting like, look at this, like 10.
We were at 15 tokens a second, our expert tiers full of coffee experts, but getting this level of speed of one GPU running off an SSD. Are you kidding me? By the way, I'm so proud of this quick little coding idea I had to visualize the experts being chosen.
It's so awesome. Let's try a different question. Boom.
And there it goes, picking the experts. And notice at the top, it's reading around 10 to 11 gigabytes per second. It's fluctuating, though.
For some reason, on this round, we slowed down a bit, around three to four tokens a second. I wonder why. Maybe I can ask a new question in the actual web interface I have here.
Why are coffee beans? Oh dang. It's going fast here.
Oh, look at that. Go reading the question, man. It's actually very fast and notice 61 % of the answers are coming from the GPU.
Oh, this is fun. Hey, it's Chuck from the future again. Now it's finally time to talk about how GPUs don't share.
And I bet you didn't know that here it is. GPUs don't like to share. What does that mean?
I mean, sure. This 50 90 is great. great at running local AI.
Have you tried it? It's fast. I watch over wifi.
I'll connect to it right now with this Mac tele Mac. Hey, this is your GPU now. And I can generate images with Figma, which I didn't know you could do that.
I'm not sure how they did that. This is really cool. And I can make videos with this love art app and I can even edit videos with the Vinci resolve and then render them.
So I'm editing on the Mac and then I'm rendering it with that massive GPU. Like that's just cool. But these are all like, single tasks.
And if we wanna treat the GPU like that family computer, it needs to be that one centralized resource, which is their big idea. I think it's a fun idea. The GPU has to be able to share, but it won't, or at least it's not designed to it's stingy.
It never actually had to share. The idea is that, you know, when you're playing a game, the game is using the GPU. Like that's what's happening when you're rendering a video that's using the GPU.
Most of it, no one taught it how to share because it didn't need to share, but now it does. was because all these AI apps are like, Hey, I want it. I wanna play with it.
I wanna use it right now. They all wanna use the GPU at the same time. And the problem is it takes time to switch because any one of these models, image model, video model, chat model can fill up the entire 32 gigabytes of VRAM.
It has just by itself. And if you wanna switch the app or the model, you have to move that sucker, all of it out of VRAM. and then move the other one in.
And if we're talking about the shared family idea, that's untenable. Like that's crazy slow. Now why size solving this by building what they call a scheduler, the scheduler runs on the box.
And what it does is when you wanna switch an app, let's say we have the image app Figma or something, but you wanna switch to video generation. The scheduler will move that model down to the SSD. That's kind of like putting the app in its pocket.
Didn't put it down. It didn't put it away. It's just somewhere else.
And when that app needs to generate another image, it can quickly. bring it out of SSD and start it up again. In theory, this should make sharing the GPU a much better experience and it makes it feasible for a phone or a laptop or a tablet to share it all at once.
But that's just a theory. Let's test it. Now I'll code it up a quick demo.
So you can actually see this visually here's the GPU and it's memory SSD right here. So you can see the parked copies. And I'm actually gonna show you without the scheduler first to show you how it kind of feels.
the speed difference. So we'll load the chat. So what it's gonna do is it's gonna load the Gemini model right now and ask it a quick question.
And this is the Mac using the GPU scenario right now. Now I'm gonna switch to an image model and it's gonna generate a quick image. Ready, set, go.
Now here's what I want you to pay attention to. And it's when I switch back to the chat app, let's switch back. It should take a minute.
Notice it was pretty much the same time as loading it from scratch. I put it on my desk now, so you can kind of hear it when it spins up. Now it's time for the parked option or the scheduler option.
And look right now, it already has the stuff loaded. So it's got the chat app loaded. It's got the parked models on the SSD, kind of like a copy of them, just ready to go.
So I'll load the chat. It's already loaded. So it answered right here.
As you can see, boom. Now I'm gonna switch to image and let's see how fast this is.
I mean, look at that.
Woo. Calm down, buddy. Before it took about let's 18 seconds.
And this took us about 8 .6. Let's switch back to chat. Boom.
Woo. What took 17 seconds before. And now it takes around four seconds.
Let's try again. Switch back to image. Pretty consistent.
Okay, cool. So the family GPU, what do you think for me? I love the vision.
I know what this can be. And after using it, the numbers don't lie. Like what they've done is impressive.
Y side has created a bunch of amazing novel solutions to consumer GPU problems and running local AI. And it's not just that like being able to game on a wireless GPU, like that's crazy, but then also run giant AI models that nobody has any business running by themselves on something like this and getting around eight tokens a second, eight words per second.
That's good. This is an early engineering model. I imagine it's gonna get better.
And then using Figma with this, that was cool. Actually that part I'm excited to see more of like mainstream apps, being able to use this GPU, using an app on your phone that believes it has a 50 90 and it's using it. Like that's crazy.
The tech is exciting. I nerded out like crazy digging into this to figure out how it works. And by the way, you can buy one of these right now.
They're selling them. It comes in this version with a 50 90. They also have a 50 60 TI version, which is a bit cheaper.
Here's the pricing right here. They'll ship in about eight weeks. So get your orders in now.
But man, this has been a wild ride. I'll catch you guys next time. Hey, you made it to the end.
At the end of my videos, I like to pray for you, my audience. Now my camera's about to die. So I'm gonna pray for you real quick.
Father, I thank you for the person on the other side of the screen. I thank you for them just being here. This is not an accident to be at the end of the YouTube video.
Who makes it to the end? So God bless them now and their family. I thank you that they are excited about tech.
And I pray that this local AI thing, even if they're not gonna use one of these Y -side devices, just the idea that local AI is accelerating, let this get them excited about what they can do in their community, what they can do for their home, what they can do for their businesses, what they can do for their church. God, show them the cool ways we can accelerate humans, 10X humans, and do things that we could never do before.
And let them not be anxious about it, but be excited about it, God. Reveal to them ways they can use AI, but also at the same time, reveal to them things they need to keep human.
Slow thinking and learning. We need that.
Bless them indeed. Again, bless their families and their lives and their jobs and everything. I ask this in your name, Jesus.
Amen. Thanks for that. Thanks for letting me do that.
I'll catch you guys next time.
The Hook
The bait, then the rug-pull.
A 750 billion parameter model on a box with 32 GB of VRAM, over Wi-Fi, while a laptop plays Cyberpunk on the same GPU. NetworkChuck opens with the claims and spends the next 23 minutes trying to explain why they shouldn't work.
Frameworks
Named ideas worth stealing.
13:49list
Four tricks to run a huge MoE model off an SSD
Rewrite expert files into equal, aligned chunks
Read 64 chunks at a time
Keep popular experts in VRAM and RAM
Split math between CPU and GPU by where the weights live
Together these took SSD reads from about 1 GB/s to 11.5 GB/s and cut per-token SSD traffic to about 1 GB.
Steal forany local inference setup where the model is larger than VRAM
04:41list
Four tricks to make a GPU usable over Wi-Fi
Fake driver so apps see a local GPU
Skip waiting on messages that don't need answers
Send only what changed, bundled and compressed
Pre-send answers the GPU knows will be asked
Cuts required bandwidth from roughly 8 Gbps to 400 Mbps while keeping the game running on the laptop.
Steal forunderstanding remote GPU and low-latency protocol design
CTA Breakdown
How they asked for the click.
VERBAL ASK
22:10product
“You can buy one of these right now... Get your orders in now.”
Sponsor pitch lands after the verdict with a $600 off link, and the sponsorship is disclosed up front at 0:38.
Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.
Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
A 38-minute build-along that turns one free Checkmk server into a single pane of glass over Linux boxes, switches, Docker containers, Proxmox VMs, a Windows gaming PC, a NAS, Plex, Home Assistant, and a fleet of AI agents.
NetworkChuck tests Jev, a decision model from TypeSafe that only answers yes/no, multiple choice or a score, and finds it beats ChatGPT on speed and cost for background automation.
One host hires a Claude Code CEO, three Hermes agents, a Codex security lead, and two local-model workers into a single AI company, then hands them a real network mystery to solve.
NetworkChuck installs DHH's Omarchy, an opinionated Arch Linux build, in under two minutes, then hands an AI agent the keys to rice, theme, and troubleshoot the entire desktop while he watches.
00:13
00:29
00:50
00:58
01:16
01:58
02:15
02:39
03:05
03:26
04:01
04:29
04:46
05:08
05:16
05:48
05:58
06:05
06:49
07:10
07:23
07:34
07:59
08:17
08:54
09:09
09:29
09:47
09:57
10:40
10:57
11:15
11:32
11:50
11:59
12:25
13:22
13:40
14:18
14:33
14:50
15:07
15:34
15:59
16:18
16:34
16:52
17:09
17:37
17:54
18:27
18:30
18:56
19:14
19:42
20:08
20:40
21:16
21:33
21:51
22:06
22:47
23:06
23:26
37:53
Video of the Day20:35
28:47
33:36
32:39
1:27:46