<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Josh Green on Medium]]></title>
        <description><![CDATA[Stories by Josh Green on Medium]]></description>
        <link>https://medium.com/@joshgreen.shopify?source=rss-5adb3bbdf17b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*BG1IldwF4oX72Vl6gTS4wQ.png</url>
            <title>Stories by Josh Green on Medium</title>
            <link>https://medium.com/@joshgreen.shopify?source=rss-5adb3bbdf17b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 01:13:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@joshgreen.shopify/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Your 3D Prints Look 3D Printed?]]></title>
            <link>https://medium.com/illumination/why-3d-prints-look-3d-printed-visible-layer-lines-gone-d03050758b92?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d03050758b92</guid>
            <category><![CDATA[3d-printer]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[3d-modeling]]></category>
            <category><![CDATA[3d-design]]></category>
            <category><![CDATA[3d-printing]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Sat, 25 Jul 2026 17:34:47 GMT</pubDate>
            <atom:updated>2026-07-25T17:34:47.235Z</atom:updated>
            <content:encoded><![CDATA[<h4>Why Sanding Is the Wrong Fix For Visible Layer Lines?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4ZAYKZgVCeGp1x7M2k0C_Q.png" /><figcaption>Same print, two finishes. Image by the author.</figcaption></figure><p>I spent about two years sanding print lines off models before I admitted the whole approach was backwards.</p><p>If you print anything you care about, you know the exact moment. The geometry comes out clean, the fit is right, the colour is right. Then you turn the part toward a window and every flat face is covered in fine horizontal lines. The object is good. It just looks printed, and you wanted it to look made.</p><p>For a long time my answer was grit. Coarse paper, then finer, then primer, then finer still. I got reasonably good at it. I also quietly ruined a lot of parts, because most of what I print is not flat. Figures, handles, terrain, grips, organic shapes. On those, sanding is a slow way to destroy the detail you just spent hours printing. Every pass rounds off the edges, and you end up with a softer, blurrier version of the model that happens to be smooth. After enough of those I stopped asking how to sand better and started asking a different question. Why are the lines so easy to see in the first place?</p><h3>The lines are not the problem. The empty space around them is.</h3><p>Here is the thing that changed how I work, and it is almost too simple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IQbAxtlktXjwCb7u_0GGmA.png" /><figcaption>A bare surface shows every line. Image by the author.</figcaption></figure><p>Layer lines vanish once you add surface textureA print line is a regular, repeating feature sitting on an otherwise smooth surface. Evenly spaced ridges, blank background. Your eye is extremely good at catching a regular pattern against an empty field. That contrast, structure against nothing, is the thing that reads as machine made. The ridges themselves are tiny. They stand out because there is nothing else on the surface to compete with them.</p><p>Once I saw it that way, the fix flipped. You have two options, not one. You can remove the ridges, which is sanding, slow and rough on detail and only possible on faces you can physically reach. Or you can remove the emptiness, by covering the whole surface in texture. Wood grain, stone, stipple, woven cloth, any irregular relief. When the surface is busy everywhere, the regular print lines stop announcing themselves, because now they are one pattern among many instead of the only pattern in a blank room.</p><h3>The world already knows this</h3><p>Look at the objects around you that are made of a single material and never look cheap.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0r61UCMrfePC7kd57827iQ.png" /><figcaption>Busy surfaces never look flawed. Image by the author.</figcaption></figure><p>A cast iron pan has a slightly rough, pebbled surface. It has machining marks and casting texture all over it, and you never notice any single one, because they are everywhere. Leather is covered in grain. Tree bark is nothing but irregular relief. None of these read as flawed, and all of them would show every imperfection instantly if they were polished mirror smooth.</p><p>Now think about a plain stone textured planter that came off a printer, next to a smooth one printed on the same machine with the same settings. The textured one looks finished the moment you lift it off the bed. The smooth one never quite does, no matter how you tune the temperature or slow down the outer wall. Same printer, same plastic. The only difference is that one surface is busy and one is bare.</p><h3>This is not an argument against sanding</h3><p>I want to be fair, because the internet loves a false binary and this is not one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uzH-pGG_0iM-p5hfPqaMyQ.png" /><figcaption>Getting rid of layer lines the slow way. Image by the author.</figcaption></figure><p>Sanding and smoothing have a real place. If you are making a single flat display piece with a clean modern look, and you have the afternoon, sanding and priming gives you a finish that texture cannot. Vapour smoothing does lovely things to the right material. I am not throwing any of that out.</p><p>But those are the exceptions in what I actually make. For the everyday pile of prints, the grips and boxes and figures and terrain, adding texture before I slice is faster, it survives on shapes I could never sand evenly, and it looks better in ordinary light. I went from sanding most things to sanding almost nothing, and my shelf looks better for it, not worse.</p><h3>What changed in practice</h3><p>The workflow now is boring, which is the point. Before I slice a model, if it has broad bare faces that will read as printed, I add a surface texture to the whole thing so the faces are no longer blank. Then I slice and print as normal. The texture is baked into the geometry, so the printer lays it down like any other detail. There is no post processing step at the end, because the finish is part of the print.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h6TTLbjbq4G-oPE5PQhMLg.png" /><figcaption>Texture first, then print without visible layer lines. Image by the author.</figcaption></figure><p>The mental shift was the hard part, not the tools. For years I treated the printed look as something to fix after the fact, with abrasives, in the way you would clean up a mistake. It is easier and it looks better to treat it as something to design out before the fact, by not leaving the surface empty in the first place.</p><p>If you have a drawer of half sanded parts and a healthy dislike of the smell of primer, try the other direction once. Take a model with a big flat face, give the whole surface a light stone or wood texture, and print it next to the smooth version. Put them both under a lamp. That side by side is what convinced me, and it took about two minutes instead of an afternoon.</p><p>For what it is worth, the browser tool I use for the texture step is ModelDirectory&#39;s texture tool. Full disclosure, it is the one I ended up building my workflow around, so I am not a neutral party. But the idea stands on its own no matter what you use to do it. Stop trying to remove the lines. Fill the space around them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d03050758b92" width="1" height="1" alt=""><hr><p><a href="https://medium.com/illumination/why-3d-prints-look-3d-printed-visible-layer-lines-gone-d03050758b92">Why Your 3D Prints Look 3D Printed?</a> was originally published in <a href="https://medium.com/illumination">ILLUMINATION</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ten jobs a good STL texturizer does that “more triangles” never will]]></title>
            <link>https://medium.com/@joshgreen.shopify/ten-jobs-a-good-stl-texturizer-does-that-more-triangles-never-will-2e9ec74f8b2a?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2e9ec74f8b2a</guid>
            <category><![CDATA[additive-manufacturing]]></category>
            <category><![CDATA[makers]]></category>
            <category><![CDATA[3d]]></category>
            <category><![CDATA[3d-printing]]></category>
            <category><![CDATA[fdm]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 08:19:40 GMT</pubDate>
            <atom:updated>2026-07-22T08:19:40.403Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Ten jobs a good STL texturizer does" src="https://cdn-images-1.medium.com/max/1024/1*jSbOYj4ekQrORtge8dFicQ.jpeg" /></figure><p>Upscaling a model sounds like a single job: add polygons. Every tool that stops there hands you a heavier file and a print that still looks printed. After pushing a lot of parts through these tools while testing other things, here is what a good STL texturizer actually does between upload and download. Ten jobs, and adding triangles is the least important one.</p><h3>1. It runs in the browser</h3><p>If step one is a desktop install and an account, it has already lost to anything that runs on a page. Drop the model, the work happens there, download it back. Friction is the reason a tool gets used on the special prints only, instead of every print.</p><h3>2. It checks the model is closed first</h3><p>A mesh with holes or gaps takes texture badly and slices worse. A good texturizer confirms the model is watertight before it starts, so you are not baking work into something already broken.</p><h3>3. It clears the faults a slicer hates</h3><p>Flipped normals, non-manifold edges, self-intersecting faces, degenerate triangles. The exact defects that make a slicer error out or quietly wreck a print. A real texturizer finds and fixes them in the same pass.</p><h3>4. It rebuilds the mesh at an even density</h3><p>Subdividing the triangles you already have keeps the old uneven density. What you want is the surface rebuilt at one uniform triangle size, because even topology is what lets texture sit consistently across the whole model.</p><h3>5. It textures the flat faces too</h3><p>Flat faces are where print lines look worst, because nothing else is there to hold the eye. So the texturizer lays texture across the flat areas as well, not only the curves. Nothing comes out dead smooth.</p><h3>6. It shapes the texture to the model</h3><p>The part cheap tools skip. One tiled pattern stamped over everything looks like gift wrap. Texture shaped to the model’s own geometry looks like it was meant to be there.</p><h3>7. It bakes the texture into the geometry</h3><p>The texture becomes real relief in the mesh, not a painted-on image and not a material setting. Real geometry is the only version that survives slicing and shows up on the print.</p><h3>8. It stays neutral about filament and slicer</h3><p>The output is just an STL with real geometry, so it prints in PLA, PETG or resin, through any slicer you already use. No special profile, no extra step.</p><h3>9. It hides the print lines as a result</h3><p>Even mesh, texture on the flat faces, texture shaped to the model, and the print lines stop standing out. Not sanded away, out-competed. The part reads as finished off the bed.</p><h3>10. It gives back a print-ready STL in one click</h3><p>At the end you download one STL that drops straight into a slicer. No watermark, no credits, no charge to export.</p><p>The one I keep coming back to, because it does all ten in the browser, is ModelDirectory’s texturizer. Most other tools do number four and stop, which is why the print still looks printed afterward. If you want the longer story, the week I gave up sanding and worked out why texture beats it, I wrote that on my newsletter: <a href="https://joshgreendev.substack.com/p/the-week-i-threw-out-my-sandpaper">the week I threw out my sandpaper</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e9ec74f8b2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What two RTX 3090s taught me about when a “better” model is actually worse]]></title>
            <link>https://medium.com/illumination/what-two-rtx-3090s-taught-me-about-when-a-better-model-is-actually-worse-474bed65cc22?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/474bed65cc22</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[gpu]]></category>
            <category><![CDATA[self-hosting]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 20:01:20 GMT</pubDate>
            <atom:updated>2026-07-20T20:01:20.003Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KbEWKhWqpljKYjnr.jpg" /></figure><p>I have a rule I keep relearning: the model that wins a benchmark headline is almost never the model I should run. I relearn it because I run a lot of this stuff on hardware I actually own, where every model I keep loaded is a real cost, not a leaderboard bragging right. This is the story of relearning it one more time, with a stopwatch, on a pair of NVIDIA RTX 3090s.</p><p>The model on trial was GLM-4.7-Flash, a 30-billion-parameter mixture-of-experts model with a memory trick called Multi-head Latent Attention. The last time I wrote about it, it was crawling on a little mini PC, and I was annoyed at the model. I was wrong to be. The real problem was a runtime that quietly was not doing the MLA math and fell back to plain attention, which made the memory balloon. So I did the honest thing and moved it onto real cards to ask a fair question: against a plain, fast, unglamorous model of the same size, does the clever one earn its place?</p><h3>The bench</h3><p>Two RTX 3090s, 24 gigabytes each, 48 total, on a modest Ryzen desktop. No NVLink, and the two cards talk to each other over a link that measured about 1.4 gigabytes a second, which is slow, and which quietly decided a lot of what follows. In one corner, GLM-4.7-Flash. In the other, an ordinary grouped-query model, the kind of dependable workhorse that never makes headlines. Same runtime for both so the tooling played no favorites.</p><p>Then I just measured, at every context length from a few thousand tokens up to 128,000.</p><h3>The first surprise: the clever model is a sprinter</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mGsO9Uw1kZPb3OKU.jpg" /></figure><p>At short context, GLM was electric, almost ninety tokens a second, more than double the plain model. And then, as the context grew, it faded. Sixty, forty, thirty, and by the deep end barely sixteen. The boring model, meanwhile, just held its pace the whole way, indifferent to how much context I threw at it. Somewhere around sixty-four thousand tokens the two crossed, and past that point the unremarkable model was simply faster.</p><p>That crossover is the entire lesson. The exciting model is a sprinter and the boring one is a diesel, and which you want depends entirely on the length of the race. The same pattern showed up in prefill, the quiet wait before the first word appears: GLM ingested short prompts about three times faster, then gave that lead back on long ones.</p><h3>Where the clever model actually earns its keep</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_N3rFYXFK3BFZpbB.jpg" /></figure><p>There is one place the fancy attention pays off, and it is not speed; it is memory. Because MLA squeezes the running memory into something small, GLM fit noticeably more context onto a single 24-gigabyte card before it had to spill over to the second one. If your problem is “I need to hold a huge document on one GPU,” that is a real, tangible win.</p><p>But even that win comes with the receipt attached. At the exact depth where GLM saved memory, it was also the slower model. The clever design does not give you something for nothing. It trades speed for memory headroom, and whether that trade is worth it is, again, a question about your specific job.</p><h3>Two cards are not automatically better than one</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7aIIUbcbkEJqM3ZK.jpg" /></figure><p>The most counterintuitive part came when I tried to use both cards at once. For a single conversation, one card actually beat two at short context, because splitting the model across the pair made every token pay a toll crossing that slow 1.4-gigabyte link, and at short context the toll cost more than the second card saved. Only once the context got long, and the work per token got heavy, did the two-card setup pull ahead. And if you are serving many people at once instead of chatting with one, both cards together were five to six times faster in aggregate. So even “should I use all my hardware” turned out to be: it depends what you are doing with it.</p><h3>The point</h3><p>I came out of this with a verdict that is almost aggressively unexciting. On two RTX 3090s: run the clever model for short, interactive, single-user work, run the boring one for long context, and split the clever one across both cards when you are serving load. There is no single winner. There is only the right tool for the shape of the job in front of you.</p><p>That is the thing the benchmark tables never print at the bottom. A model is not good or bad. It is good or bad at something, for someone, on some hardware, and the whole skill is knowing which someone you are. I keep a fast little model and a boring reliable one side by side for exactly that reason, and I reach for whichever one the task actually rewards.</p><p><em>Disclosure: I build tools on ModelDirectory that run on local hardware like the cards in this post, for example an </em><a href="https://modeldirectory.org/upscale-stl/"><em>STL upscaler</em></a><em> that leans on exactly this kind of GPU time. I measured all this to make my own run-or-rent decisions, and figured the numbers were worth sharing.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=474bed65cc22" width="1" height="1" alt=""><hr><p><a href="https://medium.com/illumination/what-two-rtx-3090s-taught-me-about-when-a-better-model-is-actually-worse-474bed65cc22">What two RTX 3090s taught me about when a “better” model is actually worse</a> was originally published in <a href="https://medium.com/illumination">ILLUMINATION</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everyone Says GLM 4.7 Flash Is Fast. My APU Disagreed.]]></title>
            <link>https://medium.com/illumination/everyone-says-glm-4-7-flash-is-fast-my-apu-disagreed-72b232522a6a?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/72b232522a6a</guid>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[self-hosted]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[mini-pc]]></category>
            <category><![CDATA[local-inference]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 07:19:37 GMT</pubDate>
            <atom:updated>2026-06-29T07:19:37.901Z</atom:updated>
            <content:encoded><![CDATA[<h4>A 30B model that only wakes up about 3B parameters per token should have flown on my APU. Instead it crawled, and the villain was not the size or the quant. It was hiding in the attention.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cHdU1qzKKV4kaUe_CM1YYw.png" /><figcaption>AI image</figcaption></figure><p>There is a promise the local AI crowd keeps whispering to itself, and I fell for it completely. A sparse model only lights up a few billion parameters at a time, so it should run fast on a modest machine. GLM 4.7 Flash is the poster child for that promise: 30 billion parameters on paper, only about 3 billion awake per token. I had a roomy APU with 96GB of DDR5 sitting there waiting for it. I expected it to fly. It crawled, and I lost an embarrassing number of evenings convinced I had broken something myself.</p><p>A quick bit of honesty first, because it explains why I could not let this go. I build ModelDirectory, and a lot of its unglamorous backend runs on my own hardware instead of a rented GPU I have to keep feeding money. So whether this model can actually earn a seat on a small box is not a hobby question for me. It decides what I can ship, and what it costs me to run.</p><p>The machine is an APU, not a tower with a graphics card in it. A Ryzen 9 7940HS with the Radeon 780M graphics baked onto the same die, and 96GB of DDR5 feeding both the CPU and the GPU at once. Nothing exotic. My everyday 30B-class model holds a comfortable 18 tokens a second on it. GLM 4.7 Flash is the same weight class, and on the same box it gave me a third of that on a good day, then got slower with every thousand tokens of context I added.</p><p>I pulled a Q4 build, ran it through Ollama on the Vulkan backend, and watched the speed sag as the context grew. At 4K context it managed 7.3 tokens a second. By 16K it was down to 2.1. At 32K, 1.1. At 64K, 0.6. At 128K it simply ran out of memory. Two things hurt to look at. Seven tokens a second at short context is already sad for a 3B-active model, and it does not fade politely, it falls off a cliff: every time the context doubled, the speed roughly halved.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2DGmcQLsWGnGk1NhDBPEIQ.jpeg" /><figcaption>Generation speed falls off a cliff as context grows, on the APU under the default runtime.</figcaption></figure><p>My gut said quantization, so I tried Q4, Q6, and Q8, the builds people actually run. They finished within a token a second of each other, and were identical by 32K. That was the moment it clicked. If squeezing the weights from 31GB down to 18GB barely moves the needle, the weights were never the problem. Something in the attention was eating me alive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XPIcAgLDmx3FvMrvquggQg.jpeg" /><figcaption>Q4 to Q8 barely changes the speed at short context. The weights were never the bottleneck.</figcaption></figure><p>GLM 4.7 Flash uses Multi-head Latent Attention, the clever memory trick DeepSeek made famous with V2. In plain language, MLA folds the running memory of a conversation, the KV cache, down into a tiny compressed form, so long chats are supposed to stay light. Beautiful idea, with one catch. The software running the model has to actually know how to do MLA. If it does not, the model just shrugs, falls back to ordinary attention, and that compressed little cache balloons to roughly seventeen times the size it was meant to be. That is the cliff. The memory explodes, the per-token math explodes, and your APU starts gasping.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Akf4F6Kj420RbZz8qovFg.jpeg" /><figcaption>The KV cache climbs into the memory ceiling, then 128K runs out of room.</figcaption></figure><p>There was a second knife in the back, too. On AMD integrated graphics the Vulkan backend has no flash attention. None. That accelerator lives on some NVIDIA drivers and almost nowhere else, so on the 780M the attention work either runs the slow unfused way or leaks onto the CPU. And here is the cruel irony of a unified-memory APU: all 96GB of that lovely DDR5 sits on one shared bus between the CPU and the graphics. Oversized cache, no fast attention, one shared lane. The model was losing on three fronts at once, and the 96GB I was quietly proud of had become the thing everyone was fighting over.</p><p>Because the whole disaster was software, the cure was software. ik_llama.cpp is a llama.cpp fork built for exactly this case, with a real small-cache MLA mode you switch on with a flag. I built it CPU only, which sounds backwards until the unified-memory part lands: on this APU the CPU reads the same 96GB at the same speed as the graphics, and only the CPU runtime had the fast attention path. It loaded the model as the DeepSeek-class architecture it actually is, and the cliff vanished. Short context went from 7.3 to about 10 or 11 tokens a second. The collapse with context was gone, it held steady. And 128K, which used to run out of memory, now fit.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uBNAfcKZkDSf5gaYSTpo8w.jpeg" /><figcaption>Same model, two runtimes: the default Vulkan path collapses, ik_llama.cpp with real MLA holds steady.</figcaption></figure><p>About a 40 percent bump at short context, and the part that actually made me exhale, the speed stopped disintegrating as the chat grew. Same weights that had been sitting on my disk the entire time. I did not re-download a single byte. The model was never too big for the box. It was just being run by software that did not understand it.</p><p>So if this ever happens to you, here is the short version. A model that is slow and gets slower with context is practically screaming check it for MLA, because the giant KV cache is the fingerprint. A smaller quant will not rescue you there: if Q4 and Q8 run at the same speed, you are attention bound, not memory bound. On AMD integrated graphics, do not assume flash attention has your back, because it can quietly desert you to the CPU. And on an APU, a CPU runtime that genuinely speaks MLA can beat the very graphics chip you bought the thing for.</p><p>The honest catch is that even once it is fixed, this model works the APU harder than a plain model of the same size, because MLA simply costs more on this hardware. Which means the real question was never can I make it run. You can. It is whether I should run this instead of the thing that is already fast on my desk. That one is a benchmark, and it is the next story.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=72b232522a6a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/illumination/everyone-says-glm-4-7-flash-is-fast-my-apu-disagreed-72b232522a6a">Everyone Says GLM 4.7 Flash Is Fast. My APU Disagreed.</a> was originally published in <a href="https://medium.com/illumination">ILLUMINATION</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Analyzed 246,000 3D Models. Here’s What We Found.]]></title>
            <link>https://medium.com/illumination/we-analyzed-246-000-3d-models-8fe362ad61a1?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/8fe362ad61a1</guid>
            <category><![CDATA[virtual-reality]]></category>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[3d-modeling]]></category>
            <category><![CDATA[statistics]]></category>
            <category><![CDATA[3d-printing]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 05:28:39 GMT</pubDate>
            <atom:updated>2026-06-15T05:28:39.529Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mn6ncIPBZx2uoCB3UqBdzQ.png" /></figure><p>ModelDirectory.org aggregates 3D models from four major platforms: Printables, Thingiverse, MyMiniFactory, and Sketchfab. We currently index 246,181 published models from 31,361 creators. That dataset represents nearly half a billion downloads.</p><p>I ran the numbers on the full database. What follows is a snapshot of the 3D model ecosystem in mid-2026, file formats, platform dynamics, category distribution, licensing, download patterns. Every number comes directly from our database. No surveys, no estimates.</p><h3>Platform Breakdown: Printables Dominates</h3><p>The distribution across platforms is not even close.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ql1a9mi5y8eVcIjsUPnDSw.png" /><figcaption>Platform share (246,181 models): Printables 76.3% (187,845) · Thingiverse 22.3% (54,834) · MyMiniFactory 1.0% (2,570) · Sketchfab 0.4% (932) — source: ModelDirectory.org</figcaption></figure><p>Printables has 3.4x more models than Thingiverse and 77x more recorded downloads. That download gap is partly a data issue: Thingiverse’s API doesn’t expose download counts as reliably. But even accounting for that, Printables is running away with this.</p><p>MyMiniFactory and Sketchfab together make up less than 1.5% of indexed models. Both serve different niches. MyMiniFactory leans toward miniatures and tabletop gaming. Sketchfab is mostly visualization and non-printable 3D. In the printable ecosystem specifically, they’re minor players.</p><h3>File Formats: STL Still Rules</h3><p>The format debate in 3D printing communities gets loud. The data is quiet about it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0zQAxmcc6ilc88PHLKnkRw.png" /><figcaption>3D file format distribution (246,181 models): STL 94.6% (232,953) · 3MF 2.4% (6,016) · STEP 1.0% (2,344) · OBJ 0.4% (1,013) · BLEND 0.1% · GLB 0.1% — source: ModelDirectory.org</figcaption></figure><p>STL at 94.6%. Despite years of advocacy for 3MF — multi-color support, embedded print settings, proper metadata — it has reached just 2.4% of published models. STEP, the format mechanical engineers prefer for parametric editability, is at 1.0%.</p><p>Everything else combined is under 1%. For practical purposes, the 3D printing ecosystem runs on STL. If you’re building tools or viewers for this space, STL support is non-negotiable. Everything else is optional.</p><h3>What People Are Printing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*03kd9cTvDLF7ALmluOxMIg.png" /><figcaption>3D model categories (246,181 models): Organisation 21.8% · Art 21.0% · Gadgets 11.1% · Home 7.7% · Mechanical 7.0% · Electronics 5.7% · Tools 5.0% — source: ModelDirectory.org</figcaption></figure><p>Organisation tops the chart — bins, trays, holders, cable management, desktop organizers. It’s the unsexy backbone of consumer 3D printing. People buy printers to print functional objects that make their space tidier.</p><p>Art at 21% includes figurines, sculptures, decorative pieces, and increasingly, articulated print-in-place toys. The most downloaded model in our database (Honeycomb Storage Wall by RostaP, 271,060 downloads) sits right at the intersection of art and organization.</p><h3>The Most Downloaded Models</h3><p>Three things win at scale: functional prints (storage wall, printbed scraper), articulated toys (octopus, dragon, shark, jointed figure), and decorative objects (moon lamp, spiral planter). McGybeer appears twice — Cute Mini Octopus and Articulated Shark — making them arguably the most successful individual creator in the ecosystem by raw download volume.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T5m8xr2noZLwCoJ5LQrUVA.png" /><figcaption>Top 10 most downloaded 3D models (246,181 indexed): Honeycomb Wall 271,060 · HexScraper 241,246 · Mini Octopus 179,722 · Infinity Cube 132,857 · LUCKY 13 131,942 · Moon Lamp 117,929 · Spiral Planter 109,047 · Water Dragon 107,452 · V29 Whistle 104,685 · Articulated Shark 100,597</figcaption></figure><h3>Licensing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_4qfyqGmahI4e6UF_AsnXw.png" /><figcaption>License distribution (246,181 models): CC BY-NC-SA 36.1% (88,952) · CC BY-SA 23.1% (56,803) · CC BY 16.4% (40,352) · CC BY-NC 14.9% (36,748) · CC BY-NC-ND 4.7% (11,692) · CC0 2.8% (6,864) — source: ModelDirectory.org</figcaption></figure><p>CC BY-NC-SA is the most popular by a wide margin. Creators want attribution. They don’t want their designs sold commercially. But they’re fine with remixing as long as derivatives carry the same terms.</p><p>Only 2.8% of models use CC0. For anyone looking to sell printed models commercially, the practical filter is this: 19% of the ecosystem uses CC BY or CC BY-SA, which permit commercial use. The rest either restricts it or doesn’t specify.</p><h3>AI-Generated Models: Still a Fraction</h3><p>There’s been a lot of noise about AI-generated 3D models disrupting the community. The numbers don’t back that up yet.</p><p>4,544 models carry the AI-generated flag. That’s 1.8% of the total.</p><p>This is almost certainly an undercount, platforms only recently started requiring AI disclosure, and many AI-generated models were uploaded before the flag existed. But even with undercounting, AI models are not yet a significant portion of the ecosystem by volume.</p><h3>Remixes</h3><p>6,755 models — 2.7% — are flagged as derivatives of other models. Lower than you might expect from a community that talks a lot about remix culture. Part of the explanation is data: not all platforms track derivative relationships, and many remixes aren’t formally linked to their parent models.</p><h3>The Average Model</h3><p>An STL file on Printables, in the Organisation or Art category, licensed CC BY-NC-SA, downloaded around 1,964 times (mean; median is much lower), not AI-generated, not a remix, and free. That’s the middle of this ecosystem.</p><h3>Caveats</h3><p>A few things to keep in mind about this data. We index models as we find them: our coverage isn’t uniform across platforms. Printables has better API access than Thingiverse, which means Printables is probably closer to complete. The download numbers for Thingiverse are particularly unreliable; their API is inconsistent about what it returns. Category classification is AI-assisted, so there will be edge cases where the label doesn’t fit. And the 246,181 figure is a snapshot from mid-2026. The database grows daily.</p><h3>Where This Is Going</h3><p>We’re adding platforms. CultCreators, Thangs, and Fab365 are in the queue. Each one changes the distribution. Thangs in particular has a large catalog that skews toward hobbyist work. We’re also running experiments on AI-flagging accuracy; the current 1.8% number is almost certainly low, and we want to know by how much.</p><p>If you’re building something in this space (a slicer, a viewer, a marketplace) and you want access to the underlying data, reach out. We’ve talked to a few developers already about API access. Nothing formal yet, but we’re open to it.</p><p>Josh Green, ModelDirectory.org</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8fe362ad61a1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/illumination/we-analyzed-246-000-3d-models-8fe362ad61a1">We Analyzed 246,000 3D Models. Here’s What We Found.</a> was originally published in <a href="https://medium.com/illumination">ILLUMINATION</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Ran Two Local LLMs on a Mini PC at Once — Benchmarks Show Why It's Pointless]]></title>
            <link>https://medium.com/@joshgreen.shopify/i-ran-two-local-llms-on-a-mini-pc-at-once-benchmarks-show-why-its-pointless-4b22c71ab4fe?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b22c71ab4fe</guid>
            <category><![CDATA[mini-pc]]></category>
            <category><![CDATA[moe]]></category>
            <category><![CDATA[local-llm]]></category>
            <category><![CDATA[benchmark]]></category>
            <category><![CDATA[self-hosted]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Wed, 27 May 2026 14:11:39 GMT</pubDate>
            <atom:updated>2026-05-27T14:24:05.708Z</atom:updated>
            <cc:license>http://creativecommons.org/licenses/by/4.0/</cc:license>
            <content:encoded><![CDATA[<h3>I Tried Running Two LLMs at Once on My Mini-PC</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*5StqLY902mXSSNQF.png" /></figure><p><em>Josh Green · May 2026 · 8 min read</em></p><h3>The Setup</h3><p>If you’ve been following my stuff, you know I’m all about squeezing maximum value out of minimal hardware. Mini PCs, home labs, self-hosted everything. So naturally, when I got my hands on a <strong>UM790Pro</strong> with <strong>96 GB of DDR5</strong>, my first thought was: <em>“Can I run two LLMs simultaneously?”</em></p><p>The answer is yes. But the better question is: <em>should</em> you? Spoiler: <strong>no.</strong> And I have the benchmarks to prove it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*DHudYQQFV4UCbffR.jpg" /></figure><p>The UM790Pro is a beast for its size. Here’s what we’re working with:</p><p><strong>CPU </strong>AMD Ryzen 9 7940HS<br><strong>GPU </strong>AMD 780M iGPU (integrated — shares system memory)<br><strong>RAM 96 GB</strong> DDR5–5600<br><strong>VRAM Pool </strong>2 GB dedicated + 46 GB GTT = <strong>48 GB</strong> total<br><strong>Bandwidth ~80 GB/s</strong> (shared between CPU and iGPU)</p><blockquote><strong><em>Key Insight:</em></strong><em> That last spec is the key to everything that follows. On a discrete GPU, the CPU and GPU have their own separate memory buses. On an APU like the 7940HS, the CPU and iGPU </em><strong><em>drink from the same straw</em></strong><em>. DDR5–5600 gives you roughly 80 GB/s, and both the CPU cores and the GPU compute units fight over every byte of it.</em></blockquote><p>I’m running <strong>Ollama</strong> as my inference server. Four models in the ring</p><p>The 35B MoE model is the big gun — my daily driver for coding and complex reasoning. The smaller models were candidates for a “sidecar” role: handling quick tasks like summarization or classification while the big model crunches harder problems.</p><h3>Baseline: One Model at a Time</h3><p>First, I benchmarked each model running alone to get clean numbers. No contention, full access to every byte of bandwidth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*EcdrQtcS-35yQ6Z3.png" /></figure><p>The 35B model at <strong>17.8 tok/s on an iGPU</strong> is genuinely impressive. That’s usable for interactive chat. The small models are blazing fast — Gemma at 42.9 tok/s on GPU is practically instant for short responses.</p><blockquote><strong><em>The Hypothesis:</em></strong><em> What if I keep the 35B on GPU and run a small model on CPU simultaneously? Best of both worlds, right?</em></blockquote><h3>The Dual-Model Experiments</h3><p>I ran four combinations, firing both models at the same time with identical prompts and measuring throughput. The results tell a clear and consistent story.</p><h3>Test 1: Both Models on GPU</h3><p><strong>qwen3.6:35b (GPU) + </strong><strong>gemma4-e2b (GPU)</strong></p><p>Both models fighting for the same GPU compute units and the same memory bus. The 35B model drops to 13.1 tok/s. Painful but expected.</p><h3>Test 2: Big Model GPU + Tiny Model CPU — “Best Result”</h3><p><strong>qwen3.6:35b (GPU) + </strong><strong>qwen2.5:1.5b (CPU)</strong></p><p>This was the best result. The 1.5B model is tiny enough that its CPU inference doesn’t hammer memory bandwidth too hard. The big model only drops 16%. But the small model gets cut in half.</p><h3>Test 3: Big Model GPU + Medium Model CPU-Forced</h3><p><strong>qwen3.6:35b (GPU) + </strong><strong>gemma4-e2b (CPU, num_gpu=0)</strong></p><p>Forcing Gemma to CPU didn’t help. The 4.6B model doing CPU inference generates enough memory traffic to compete with the GPU’s reads. Both models suffer.</p><h3>Test 4: The Worst Case — KV Cache Explosion</h3><p><strong>qwen3.6:35b (GPU) + </strong><strong>qwen3:4b-instruct (CPU, num_gpu=0)</strong></p><p>This was the disaster scenario. The 4B instruct model supports a 256K context window, and its KV cache ballooned to <strong>24.2 GB</strong> at full context. Combined with the 35B model’s 32 GB VRAM allocation, we were pushing close to the system’s total memory bandwidth capacity. Both models crawled.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*tcNDNW4rmTn7L8IL.png" /></figure><h3>The Memory Architecture Problem</h3><p>Here’s what’s actually happening inside this machine. The diagram below shows why every dual-model configuration suffers from the same fundamental constraint.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*7JeMZCkBp0R2vee6.png" /></figure><p>The VRAM pool breaks down like this:</p><ul><li><strong>2 GB dedicated VRAM</strong> — physically reserved for the iGPU</li><li><strong>46 GB GTT (Graphics Translation Table)</strong> — system RAM mapped into GPU address space</li><li><strong>48 GB total</strong> GPU-accessible memory</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*MAQ0gHCCMh8mWFK9.png" /></figure><p>When both a GPU model and a CPU model are running, they’re both streaming weights from the same DDR5 DIMMs through the same memory controller. The GPU doesn’t have its own GDDR6 with 300+ GB/s bandwidth like a discrete card. It’s sharing the same <strong>80 GB/s pipe</strong> as everything else.</p><blockquote><strong><em>It’s not a compute bottleneck — it’s a memory bandwidth bottleneck.</em></strong></blockquote><h3>The Real-World Conclusion</h3><p>I was testing this because I wanted to run an agent framework — think: a planning model plus an execution model working together. The idea was the big 35B model handles complex reasoning while a small model handles quick tool-calling or classification.</p><p>But here’s the thing:</p><blockquote><strong><em>Agent frameworks run tasks sequentially, not in parallel.</em></strong></blockquote><p>The workflow looks like this:</p><p><strong>Planner thinks</strong> → <strong>Executor acts</strong> → <strong>Planner thinks</strong> → <strong>Executor acts</strong> → …</p><p>At any given moment, only one model is actually generating tokens. The other is just sitting there, loaded in memory, doing nothing — but still occupying VRAM or RAM that could be used for bigger context windows.</p><p>The dual-model setup gives you:</p><ol><li><strong>Worse throughput</strong> on the big model (11–15 tok/s vs 17.8 tok/s)</li><li><strong>No parallelism benefit</strong> in sequential agent workflows</li><li><strong>Wasted memory</strong> keeping a second model loaded</li><li><strong>Risk of OOM crashes</strong> — Ollama’s iGPU memory reporting has a <a href="https://github.com/ollama/ollama/issues/14953">known bug (issue #14953)</a> that can cause crashes with multiple loaded models</li></ol><h3>The MoE Insight</h3><p>Here’s the aha moment that made me feel silly for even trying this. The qwen3.6:35b model is a Mixture of Experts architecture. It has 256 experts but only activates <strong>8 per token</strong>. That means for any given token, it&#39;s doing roughly the compute of a 4-5B parameter model while having the knowledge of a 36B parameter model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*fo1dz-wgs5OpVOyj.png" /></figure><p>Read that again. The big model <strong>already IS</strong> the small model in terms of per-token compute cost. MoE gives you the reasoning depth of 35B parameters with the inference speed of a much smaller model. Running a separate small model alongside it for “fast tasks” is <strong>solving a problem that doesn’t exist</strong>.</p><p><strong>17.8 tok/s</strong> for 35B-class reasoning is already fast enough for everything I throw at it. Adding a second model only makes it slower.</p><h3>Bonus: Ollama Storage Gotchas</h3><p>While poking around, I found a few things worth mentioning about how Ollama manages model storage.</p><h3>Shared Blobs Save Disk Space</h3><p>I had qwen3.6:35b, qwen3.6:latest, and qwen3.6:35b-nothink all listed as separate models. Turns out they all point to the same <strong>23.9 GB blob</strong> on disk. Ollama uses content-addressed storage, so identical weights are stored once regardless of how many tags reference them.</p><h3>Orphan Blobs Waste Disk Space</h3><p>After deleting some models, I found a <strong>12.9 GB orphan blob</strong> sitting in ~/.ollama/models/blobs/ that no tag referenced anymore. There&#39;s no ollama prune command (yet), so I had to manually cross-reference blob hashes against manifest files and delete the orphan by hand. Check yours - you might be surprised.</p><h3>One Model to Rule Them All: TL;DR</h3><p>Running two LLMs simultaneously on a shared-memory APU is technically possible but practically pointless:</p><ul><li><strong>DDR5 bandwidth (~80 GB/s)</strong> is the bottleneck, not compute</li><li>Both models compete for the <strong>same memory bus</strong> regardless of CPU vs GPU assignment</li><li>Agent frameworks run <strong>sequentially</strong> anyway — no parallel benefit</li><li>MoE models like qwen3.6:35b already give you big-model smarts at small-model speeds</li><li><strong>Just run one model. Use the freed memory for bigger context windows instead.</strong></li></ul><p>Save your 96 GB of RAM for what it’s actually good at: loading <strong>one big model</strong> with a massive context window. That’s where shared-memory APUs genuinely shine.</p><p><em>Tested on: Minisforum UM790Pro · AMD Ryzen 9 7940HS · 96 GB DDR5–5600 · Ollama v0.9.x · Ubuntu Linux — Josh Green — May 2026</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b22c71ab4fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Free LLMs on OpenRouter Keep Going 404. I Fixed It With 120 Lines of Python]]></title>
            <link>https://medium.com/@joshgreen.shopify/free-llms-on-openrouter-keep-going-404-i-fixed-it-with-120-lines-of-python-aab4d8d093c1?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/aab4d8d093c1</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[openclaw-tutorial]]></category>
            <category><![CDATA[open-router]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[openclaw]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Sun, 08 Mar 2026 17:54:44 GMT</pubDate>
            <atom:updated>2026-03-08T18:20:36.649Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Dj4ZNdVG3iPccHhz.png" /></figure><p>I built a small pipeline on OpenClaw to stay on top of 3D printing news.</p><p>Nothing fancy — a Python script that pulls from YouTube, RSS feeds, and Reddit, uses a free LLM to summarize what’s worth reading, and emails me a digest. I use OpenRouter’s free tier because I’m cheap and the models are good enough for summarization.</p><p>It worked great. For about two weeks.</p><p>Then I started getting errors.</p><h3>The problem nobody talks about</h3><p>Here’s something I didn’t fully appreciate until it bit me: free models on OpenRouter change constantly. Models get added, removed, rate-limited into uselessness, or quietly replaced with different versions. If you hardcode your model list — which every tutorial tells you to do — you’re building on sand.</p><p>One morning I woke up to this:</p><pre>[06:03] LLM HTTP 404 [openai/gpt-oss-120b:free]: model not found [06:03] LLM HTTP 429 [nousresearch/hermes-3-llama-3.1-405b:free]: rate limited [06:03] LLM HTTP 404 [mistralai/mistral-small-3.1-24b-instruct:free]: model not found [06:03] All free models exhausted - returning empty</pre><p>Three of my six hardcoded models were dead. The pipeline silently produced nothing. I missed a week of content before I noticed.</p><p>Hardcoded lists are technical debt. Free model availability is a moving target. These two facts collide badly.</p><h3>The fix: treat the model list as a live data source</h3><p>OpenRouter has a public endpoint — no auth required — that returns their full model catalog:</p><pre>GET https://openrouter.ai/api/v1/models</pre><p>It returns ~346 models right now. Filtering to free ones with decent context windows gives you 10–15 candidates. The question is: which ones are actually worth using?</p><p>I wanted to rank them. My criteria:</p><ol><li><strong>Context window</strong> — longer is better for summarization. A 262K context model can swallow an entire article thread without chunking.</li><li><strong>Model size</strong> — bigger models write better. A 70B model beats a 7B model for prose quality.</li><li><strong>Historical reliability</strong> — has this model actually worked when I’ve called it before?</li></ol><p>That last one is the one nobody tracks. So I built tracking.</p><h3>model-registry.py — the discovery layer</h3><p>The registry script runs once every 6 hours. It:</p><ol><li>Checks if the cache (~/.openclaw/free-models.json) is fresh - if yes, exits in &lt;100ms (just a file stat)</li><li>If stale, hits the OpenRouter catalog and scores every free model:</li><li>Takes the top 10, writes them to free-models.json</li><li>Logs a diff — “Added: X, Removed: Y since last run”</li></ol><p>The diff log is where it gets interesting. On my first run after building this, I discovered two models I’d never heard of that scored in my top 6. One of them — qwen/qwen3-next-80b-a3b-instruct:free - has a 262K context window and an 80B parameter count. It&#39;s now my primary model. It wasn&#39;t in any tutorial I&#39;d read.</p><h3>model-metrics.py — the performance layer</h3><p>HTTP 200 doesn’t mean the model was useful. A model can return 200 with three sentences of hallucinated nonsense that breaks your JSON parser downstream.</p><p>So I added tracking at two levels:</p><p><strong>Level 2 — parse success (</strong><strong>parse_ok):</strong></p><p>After every call that expects structured JSON, I record whether the downstream parsing succeeded:</p><p>parse_ok is the metric I care about most. It answers: was this model actually useful, not just technically responsive?</p><p>After a week of pipeline runs, I get a table like this:</p><pre>Model calls ok% p_ok% avg_ms errors meta-llama/llama-3.3-70b-instruct:free 47 94% 88% 1240ms qwen/qwen3-next-80b-a3b-instruct:free 31 97% 91% 1180ms openai/gpt-oss-120b:free 12 58% 42% 1890ms 5×404 nousresearch/hermes-3-llama-3.1-405b:free 8 62% 55% 2100ms 3×404</pre><p>The last two models look fine on paper (they’re large, they have long context) but they’re dying constantly. Their scores get penalized:</p><p>When the registry next refreshes, those models sink to the bottom of the fallback chain. Automatically. Without me touching anything.</p><h3>The result</h3><p>The pipeline now:</p><ul><li>Discovers new free models within 6 hours of them appearing on OpenRouter</li><li>Drops dead models from the rotation within one pipeline run</li><li>Prioritizes models with proven parse reliability, not just raw specs</li><li>Costs $0.00 extra — one public HTTP GET every 6 hours</li></ul><p>The whole thing is ~250 lines across two files. No pip dependencies for the registry itself (stdlib only — json, urllib, sqlite3). The metrics use SQLite so they survive reboots and redeploys.</p><h3>Grab the code</h3><p>model-registry.py and model-metrics.py - both standalone, drop them next to any script that calls OpenRouter:</p><p>Run the registry as a preflight step before any pipeline that uses free models. If the cache is fresh, it exits immediately. If it’s stale, it updates in ~1 second.</p><pre>python3 model-registry.py --max-age 21600 # refresh if &gt;6h old python3 your-pipeline.py # now uses fresh model list</pre><p>The thing I keep thinking about: I built this to find 3D printing news: the RepRap machines that print their own parts. Then foraging for news made me realize I needed this algorithm. Now the algorithm helps me find better news about the Van Neuman probe itself. It’s turtles all the way down — but at least they’re free turtles.</p><p>Full code on GitHub Gist: <a href="https://gist.github.com/joshgreen-dev/ce3d2ecef000fab48488eddca9fa6bbd">https://gist.github.com/joshgreen-dev/ce3d2ecef000fab48488eddca9fa6bbd</a></p><p><em>Originally published at </em><a href="https://dev.to/josh_green_dev/free-llms-on-openrouter-keep-going-404-i-fixed-it-with-120-lines-of-python-43i1"><em>https://dev.to</em></a><em> on March 8, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aab4d8d093c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Never Had Such a Good Grip on Funcional Prints Before]]></title>
            <link>https://medium.com/@joshgreen.shopify/i-never-had-such-a-good-grip-on-funcional-prints-before-910d7f4fa7a8?source=rss-5adb3bbdf17b------2</link>
            <guid isPermaLink="false">https://medium.com/p/910d7f4fa7a8</guid>
            <category><![CDATA[3d]]></category>
            <category><![CDATA[3d-printing]]></category>
            <category><![CDATA[3d-design]]></category>
            <category><![CDATA[3d-modeling]]></category>
            <category><![CDATA[3d-printer]]></category>
            <dc:creator><![CDATA[Josh Green]]></dc:creator>
            <pubDate>Sat, 07 Mar 2026 09:45:18 GMT</pubDate>
            <atom:updated>2026-03-07T10:12:25.400Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9KVnYgQdIwlaxUoeVfDFOg.jpeg" /><figcaption>Design on lemme.world</figcaption></figure><p>I bought my Bambu Lab P1S last year after moving to Budapest. Cheap rent, fast internet, and suddenly I had space for a hobby that wasn&#39;t just staring at VS Code for 14 hours a day.</p><p>Everyone warned me I’d print &quot;a few useful things then revert to benchies and baby Yodas.&quot; They weren’t entirely wrong, I definitely have a small army of calibration cubes I should throw out. But <a href="https://lemmy.world/post/43897576">prints like the one I saw today</a> remind me why I got into this in the first place.</p><p>Someone designed and printed a custom hand control hoods backing for their road bike. Not a phone mount. Not a GoPro adapter. The actual rubberized part your palms rest on for hours during a ride.</p><h4>The Problem with Stock Parts</h4><p>I spent three years doing Shopify theme development, and one thing that stuck with me: most products are designed for the mythical &quot;average user.&quot; That works fine if you’re selling t-shirts. It doesn’t work when you’re talking about close contact human anatomy and high-performance equipment.</p><p>Road bike hoods are a perfect example. They’re mass-manufactured to fit some statistical middle ground of hand size and grip preference. My hands are slightly larger than average — not enough that I need custom everything, but enough that stock hoods always feel slightly off after a century ride.</p><h4>Why This Print Matters</h4><p>Being able to model your own hood backing and iterate on the shape changes everything. Too thick? Adjust the model. Want more texture in one area? Add it. Need a different angle for your specific bars? Measure twice, print once.</p><p>This is the kind of application that justifies the entire printer for me. Not the ability to make plastic trinkets cheaper than Amazon, but the ability to make things that don&#39;t exist for sale anywhere.</p><h4>The Material Question</h4><p>Here&#39;s where it gets interesting. Hoods need specific properties — grip when your hands are sweaty, some give so they&#39;re comfortable, but enough structure that they don&#39;t deform when you&#39;re pulling hard on a climb. Weather resistance matters too.</p><p>PLA won&#39;t survive a wet ride. ABS might work but it&#39;s not exactly pleasant against your skin. TPU seems like the obvious choice, though getting the right shore hardness would take some testing. Maybe nylon with a soft-touch coating?</p><p>I haven’t printed cycling components myself yet. My P1S mostly runs functional prints — brackets, organizers, the occasional prototype for a friend’s product display. But seeing functional bike parts like this makes me want to branch out.</p><h4>What&#39;s Next</h4><p>I need to find a local bike shop that&#39;s 3D-printing-curious. Or just suck it up and start modeling my own solutions to the minor annoyances that aren&#39;t worth designing and injection-molding, but are absolutely worth a weekend of CAD and a $2 print.</p><p>If you’ve done cycling components, hit me up. I’d love to know what materials actually hold up in the real world — not just in theory, but after six months of road grime and sweat.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=910d7f4fa7a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>