Why would folks be better paying 5.5% fee to OpenRouter ("Open") if most people just use one or two providers? Just use the provider's API.

The routing automatically routes you to other inference providers (for the same model) if/when the original provider goes down.

It's a convenience cost, for sure, but it's not valueless in a fast-moving world. Certainly if you're comfortable with one provider and it's cheaper, do that.

For me the largest value-add is the unified API. Being able to instantly start trialling a new model with zero code changes is well worth 5%. The other part is not having to deal with billing for multiple platforms.

Not to mention, that Opus cost orders of magnitude more money. These are VERY impressive and usage.

FAANGS love to give away money to get people addicted to their platforms, and even they, the richest companies in the world, are throttling or reducing Opus usage for paying members, because even the money we pay them doesn't cover it.

Meanwhile, these are usable on local deployments! (and that's with the limited allowance our AI overlords afford us when it comes to choices for graphics cards too!)

So we spent more on interest for the deficit than we spent on the doubling the combined spending on all of the following:

transportation government operations natural resources community development education & social services agriculture international affairs science & space and energy

...anxiety rises.

Not really. That is federal spending, right? So your local transport authority or most of the funding of a local schopl, for example, wouldn't be included here?

yeah, the context is federally here; so from my federal income taxes which are MUCH higher than my state, sales, and property taxes combined

I'm sure its happened before, but this is the first time i finally get to see some sort of modern hardware in KiCad.

Pretty cool to see all 6 layers, paste layers, and adhesive layers as well. I've always wondered how the cake was made and if big projects do/could use KiCad. Seems like a lot more work relative to those Single Layer PCBs on YouTube for things like emulators and custom PCBs. Glad I now know for sure, that I can't do this.

Paste and adhesive are spat out by KiCad as part of the manufacturing outputs. It works pretty much the same way other EDA packages like altium do - the extra layers are part of the part footprint. If you don’t design your own footprints it’s basically no extra work to generate those.

You almost certainly could do it - obviously with some time investment. Getting multi layer PCBs made is surprisingly affordable now.

The Reform laptop project is open hardware: https://source.mnt.re/reform/reform

I encourage you to browse it, I found that while challenging, it does not seem unreachable to get to that level of proficiency in KiCad.

Depends on any project ideas, but as a newbie to hardware dev and with my own small scope eurorack module idea, I am having a lot of luck with flux.ai. Even got a small order of 5 PCBs printed for under $200.

I use pnpm, but even so: thankfully naming things is hard, and all my env variable names are very_convuluted_non_standard_names for things lol.

That's why it should be rounded for everything. No pennies should probably mean that any final transaction totals are rounded to the nearest nickel. Whether they pay with cash, credit, debit, snap, gift card, etc...

IMO, rounding for cash purchases only sounds worse than keeping the pennies.

1.5 billion used to be an absolute ridiculous number to pay for a company not long ago. AOL? 1990s AOL?

But with 5 trillion dollar companies these days that are "worth" more than the entire GDP of Germany, why not. It's not real. It's just a number on a computer at this point.

Huh? Did you read the link? Did you notice the ONE screenshot clearly shows the app has a material-ui look.

I'm going to say this because I think you might not know this, but also because I think many others might not have thought about this:

Almost always, a programming language is UI agnostic. Swift SDK for Android means: You can now write Android Apps in Swift. This doesn't magically include Apple's components / SwiftUI. When you write code for a platform, specifically an SDK for an OS, all you do is expose that platform to that language.

So, as long the SDK/bindings are there, a new "Window" means whatever a the OS thinks is a Window. A Button is what is defined (or exposed/binded to) as a Button in Android.

Swift was sorta released for Windows: a new Window looks like a generic Win32 Window. The same one you would get if you used C, C++, Rust, etc..

All your examples are GREAT examples to explain how this works: - Flutter has "Cupertino" to allow people to use Flutter to make Apple apps, and not have to learn names/methods/interface of the native Apple UI. - React Native: A LOT of work was put in to make/bind Apple native objects to a React component. And the same for Android.

So again:

The Swift SDK for Android means you can write your Android apps in Swift. The same apps you might of wrote in Java or Kotlin, you can now use Swift. Meaning whatever it looked like in Java/Kotlin (using native api's), it would look like in Swift.

The SwiftUI, Apple's component library written/exposed to Swift, is something completely different.

> Almost always … a new "Window" means whatever a the OS thinks is a Window. A Button is what is defined (or exposed/binded to) as a Button in Android.

But not always, and when it’s not true, it sticks out like a sore thumb. It’s convenient for developers, but produces apps that have this uncanny valley “this isn’t quite right” quality to them. Adobe used to do this when I worked there 20 years ago (honestly don’t look at modern Adobe software if I can help it so I don’t know if they still do) with an internal component called Adobe Dialog Manager that was built expressly so developers didn’t need to worry about native widgets. The result was this “adobeness” to all the ui elments on both platforms (at this point we are talking windows vs macOS). There was no os-level button. There was an ADMButton on both platforms and it was hand-rolled behavior for rollovers and drawing styles and general interaction rules and it was this pleasantly uniform experience that sucked equally everywhere.

It *is* confusing but in actuality, it kind of works: It's a Windows Subsystem - as in the Hypervisor/VM platform - to boot a Linux VM. And, more importantly IMO, Linux distro is using this Windows Subsystem for: booting, drivers, and networking (.e.g. the "/sys/wsl" folder, and whether the Window Subsystem will generate fstab, etc..)

The "demo" is kind of bologna.

1) The code that is running is not what's presented; it executes (non-transpiled) vanilla JS.* Why not just show that?

2) Removing the box shadow massively makes the two closer in performance.

3) The page could just be one sentence: "Reflowing the layout of a page is slower than moving a single item." GPU un-related.

---

*Code that actually is running:

```js

        , u = t => {
        h && clearTimeout(h),
        l.forEach( (e, s) => {
            const {top: o, left: n} = m[r[s]];
            t ? (e.style.transform = "translate(0px, 0px)",
            e.style.opacity = "0.7",
            e.offsetHeight,
            e.style.transform = `translate(${n}px, ${o}px)`) : e.style.transform = `translate(${n}px, ${o}px)`,
            e.style.top = "",
            e.style.left = ""
        }
        ),
        t && (h = window.setTimeout( () => {
            l.forEach(e => e.style.opacity = "1")
        }
        , 500))
    }
        , d = t => {
        y && clearTimeout(y),
        l.forEach( (e, s) => {
            const {top: o, left: n} = m[r[s]];
            e.style.top = `${o}px`,
            e.style.left = `${n}px`,
            e.style.transform = "",
            t && (e.style.boxShadow = "0 14px 28px rgba(239,68,68,0.45)") // REMOVING THIS LINE = BIG DIFFERENCE
        }
        ),
        t && (y = window.setTimeout( () => {
            l.forEach(e => {
                e.style.boxShadow = "none"
            }
            )
        }
        , 500))
    }
           

```

Good points.

1) I thought of giving an easier to read example. I just moved the example to react, so the snippets actually match exactly what's going on in the background.

2) It is true! Though, using shadows on the optimized code doesn't slow it down. I added more toggles to test same effects on transform and top/left implementations.

3) I think it's still interesting to start with some thought and then observe that in practice things are different really. In fact, thanks for all the feedback, as it made me go back and do more investigation.

If you don't mind you can give the article a second look now :)

> The "demo" is kind of bologna.

The word you are looking for is "baloney". They are pronounced differently.