标签：#os

The installation utility EasyDMG makes it so you never drag and drop an icon again.

Observatories have been built in mines, deep under the Antarctic ice sheet, and elsewhere in an effort to detect the fleeting particles.

Cloud-based AI has two persistent problems for mobile developers: latency, because every inference call is a round trip to a server, and privacy, because user data has to leave the device to be processed. By 2026, Apple has shipped enough of a native stack that bypassing the cloud entirely — architecting genuinely autonomous agents that run inference, reasoning, and action selection directly on-device — has moved from a theoretical exercise to a practical, documented architecture pattern. Why Local-First Is the 2026 Competitive Edge The clearest signal of how seriously Apple is treating this shift arrived at WWDC 2026 with Core AI, a new OS-level framework built directly into Apple Silicon. Core AI allows developers to load, specialize, and run AI models entirely on-device — including local language models up to 70 billion parameters — with zero server dependency and zero token cost. Models are automatically specialized for the hardware they run on, with ahead-of-time compilation support for fast load times. That's a meaningfully different proposition than earlier on-device AI efforts: it's Apple positioning local inference as genuinely competitive with cloud-scale models, not just a lightweight fallback for when connectivity is poor. The Three-Piece Agent SDK As of 2026, Apple effectively ships three developer-facing pieces that together form something close to a full AI agent SDK. The Foundation Models framework handles on-device inference — direct, programmatic access to the same large language model that powers Apple Intelligence itself, running on the device's Neural Engine rather than through a wrapped cloud API. App Intents exposes an app's actual capabilities to that intelligence, acting as the action layer an agent can call into. Private Cloud Compute (PCC) handles the cases that genuinely exceed on-device capacity, providing a scale fallback rather than a default path. The on-device model handles reasoning, App Intents handles action, and PCC handles scale

Amazon DynamoDB recently introduced native vector search, allowing developers to store embeddings alongside application data and run approximate nearest-neighbor queries directly from DynamoDB without using a separate vector database. The feature supports filtered similarity searches and configurable vector indexes for semantic search workloads. By Renato Losio

App Review rejected my iOS app under Guideline 2.1. The note said reviewers were unable to locate the App Tracking Transparency permission request when they tested the build. The prompt worked on my iPhone. Every single launch. It just didn't work on theirs. The cause turned out to be two properties of the ATT API that are easy to miss individually and genuinely nasty in combination: together they produce a bug that is invisible on a fast device and completely reproducible on a slow one. Your test device is fast. The reviewer's device is not necessarily. This post is the root cause, the fix I shipped, and the list of other things that silently suppress the prompt. The two facts that explain everything 1. iOS only presents the ATT prompt while your app is active Apple's documentation for requestTrackingAuthorization(completionHandler:) states, for iOS 15 and later: "Calls to the API only prompt when the application state is UIApplicationStateActive." That's UIApplication.State.active — not merely "in the foreground," and not "the code is running." During launch there is a window where your JS/UI is already executing but the app is still inactive : splash screen dismissal, the first render, a modal transition animating in or out. Call the API in that window and iOS declines to present. 2. When iOS declines to present, you don't get an error You get notDetermined back ( undetermined in expo-tracking-transparency ) — which is the exact same value you get when the user simply hasn't answered yet. There is no "I couldn't show it" signal. There is no thrown error. There is no presented: false flag. From the return value alone, "the user hasn't decided yet" and "iOS silently no-op'd your request" are indistinguishable. That's the trap. The API looks like it succeeded. The bug I shipped Reduced to its essentials: // Called during startup, while the splash screen was still going away. const { status } = await requestTrackingPermissionsAsync (); const granted = status === ' gr

Nikolay Samokhvalov has developed PGSimCity, an open-source educational tool that visualises PostgreSQL mechanics as a 3D spatial simulation in the browser. It assists backend developers and site reliability engineers in understanding SQL and the dynamics of kernel execution. The project is available on GitHub and aims to enhance understanding of database architecture through interactive elements. By Olimpiu Pop

I help run a small agent organization whose entire success condition is one sentence: it keeps running when nobody is watching. Last week its operator — who does not write code — installed a self-hosted agent gateway on a Mac, from nothing, in one sitting. I logged every place it broke. All eleven below actually happened. None of them are hypothetical, and none of them are the interesting parts of self-hosting. They are the boring parts, which is exactly why nobody writes them down. One framing note before the list. Every individual item here is documented somewhere. What is not documented anywhere I could find is the order , and the fact that fixing item 3 creates item 4, which creates item 5. A non-developer doesn't fail because a step is hard. They fail because step 3's official doc ends before step 4 exists. The eleven 1. Homebrew requires an Administrator account Cause: No Node on the machine, so the install path fell through to Homebrew, which wants admin. Fix: Don't grant admin. Install Node from the official .pkg in the admin account instead, then work in the unprivileged one. Move the part, not the privilege. This turned out to be the single most useful rule of the whole install. Every time the answer was "just give this account admin," it was the wrong answer. 2. Copy-paste doesn't cross macOS user accounts Cause: The clipboard is per-session. Obvious in retrospect, invisible while it's happening — you copy a token in one account, switch, and paste yesterday's clipboard. Fix: /Users/Shared as the only transfer path. Everything moves as a file. 3. npm install -g fails with EACCES Cause: Default prefix is /usr/local , which the unprivileged account cannot write. Fix: npm config set prefix ~/.npm-global 4. It installed, but command not found Cause: Direct consequence of 3. The new prefix's bin isn't on PATH . Fix: One line in ~/.zshrc . 5. The install-scripts prompt keeps coming back Cause: --allow-scripts applies to that invocation only . It looks like the s

This is a submission for Weekend Challenge: Dog Days Edition What I Built Pawford...

"How much does it cost to put an app on the App Store" gets answered inconsistently online because most answers either only count Apple's fee, or only count hardware, or quietly assume you're renting expensive cloud infrastructure you don't actually need. Here's every cost, split into what's mandatory and what's a choice. Mandatory: Apple Developer Program — $99/year This is the one cost nobody can avoid. To submit any app to the App Store — free or paid, one app or fifty — you need an active Apple Developer Program membership, which is $99/year, billed annually, direct to Apple. There's no one-time version and no way around it. (There is a free-tier Apple ID for personal on-device testing without paying this, but it doesn't let you submit to TestFlight external testers or the App Store — for an actual public release, the $99/year membership is required.) Required, but where you have genuine choices: building and signing To submit a build, something has to run Xcode's command-line signing and archive tools — that part isn't optional. Where you have a choice is what runs it: Option Cost Recurring? Buy a Mac ~$799+ (Mac mini, entry price) No Rent a cloud Mac ~$20–100+/month Yes GitHub Actions, public repo $0 No GitHub Actions, private repo $0 up to a monthly allowance, then per-minute Only if you exceed the free allowance The short version on that last row: on a public repo, this line item can legitimately be $0, indefinitely. Optional or one-time: the things people assume cost more than they do App Store screenshots and marketing assets. You can generate these yourself for free — from the Simulator or a physical device — no paid tooling required. A physical iPhone for testing. Not strictly required to submit, but you'll want one to sanity-check the finished app before release. TestFlight itself. Free, included in the $99/year membership. App Store listing itself. Free — no fee to list an app beyond the membership. Adding it up For someone shipping a side project on a

GitHub Actions is GitHub's built-in CI/CD system — it spins up a fresh virtual machine, runs whatever commands you tell it to, and tears the machine down when it's done. It supports Linux, Windows, and macOS runners. The macOS runners are the interesting part here, because they're actual macOS machines with Xcode's command-line build tools available, which means they can build and sign iOS apps — not just run tests. The headline rule: public repos are free On a public repository, standard GitHub-hosted runner minutes — including macOS — don't cost anything, on any plan, including the free plan. It's a genuine free tier, not a trial or a limited allowance that runs out. One nuance: this covers standard runners. GitHub also offers "larger runners" (more CPU/RAM) — those are billed regardless of repo visibility. A default macOS build for signing and archiving a typical app doesn't need one, so this rarely matters in practice. What changes on a private repo If your repository is private, you get a monthly allowance of free minutes instead of unlimited free usage: Plan Included minutes / month Free 2,000 Pro 3,000 Team 3,000 The number that actually matters for iOS builds is how fast macOS runners burn through that allowance. macOS minutes cost roughly 10x GitHub applies a multiplier against your included minutes: Linux runners run at the baseline rate, macOS runners run at roughly 10x that rate. A 6-minute macOS build eats through the same allowance as roughly 60 minutes of Linux CI. Applied to the table above, a Free-plan private repo effectively gets around 200 macOS-runner-minutes worth of free build time per month before you're billed per minute past it (Pro/Team works out to roughly 300). The practical upshot: if you're fine building in the open, a public repo gets you unlimited macOS build minutes at zero cost, indefinitely. If you'd rather keep the code private, everything about the pipeline still works the same way — you're just drawing from a metered allowance

I was cleaning up the UI on a side-project iOS app and did one thing: set Dynamic Type to XXXL and screenshot every screen. Reading the code had turned up nothing. The screenshots showed problems immediately. Eleven of them, in the end. All the same cause. Here's the conclusion first. "A parent that pins things side by side" × "text that grows" is not a bug, it's a pattern. And in Japanese it breaks reliably worse than in English. English truncates. Japanese stacks vertically. Same layout, different failure depending on language. English wraps at word boundaries and, failing that, ends in … . You can't read it, but you can tell something was cut. Japanese doesn't do that. It can break between almost any two characters, so once a column is squeezed to one character wide, you get one character per line, stacked downward. Actual output: Rendered Intended Paire / d / Macs Paired Macs ( broken mid-word ) Claud / e / Code Claude Code One character per line "実行中のセッション" (Running sessions) Three step labels stacked vertically A three-step horizontal stepper De / mo , turning the capsule into a circle A "Demo" badge Paire / d / Macs is English breaking mid-word. Once the column has only a few characters left, even English gets there. Japanese gets there much earlier. The cause had the same shape every time Nearly all eleven were this: HStack { Image ( systemName : icon ) . frame ( width : 44 ) // fixed Text ( label ) Spacer () Text ( value ) // pinned right } The 44pt icon and the trailing value claim their width first, leaving the label column a few characters. The fix: rows that carry a value drop the value to the line below — but affordances like chevrons and toggles stay on the right. That row component was shared across the whole settings tree, so fixing one place fixed the entire settings screen. Which also means one decision inside a shared component was breaking eleven screens. ViewThatFits is not a general answer I used ViewThatFits to switch to a stacked layout. It

The morning after I lost my job, my Mac finished and filed an ASMR video. Nobody asked it to. It just ran. In the first post, I walked through the structure of the pipeline itself — ComfyUI × FFmpeg × the Freesound API, generating long-form ASMR videos with nothing but free tools. This second post covers the other half: putting that pipeline on macOS launchd so it fires at a fixed time every day, and the self-healing logic that gets the script past the "cold start" problem, where you boot the Mac and ComfyUI simply isn't running. Two numbers do most of the work here: the ComfyUI startup wait went from 180 seconds to 600, and the Freesound download timeout went from 90 seconds to 240. Before those changes, mornings failed 2–3 days a week. Why this setup works The ceiling on manual work Making a single 30-minute ambient ASMR video carefully takes 2–3 hours of hands-on time. Tuning image-generation prompts, layering the BGM, checking the loop points, building the thumbnail, filling in YouTube metadata — each step is small, but they stack up. Trying to hold 30 videos a month means 60–90 hours of pure labor. I attempted it while holding a side job, and it collapsed in two weeks. That was the first time I understood that "scaling output" isn't about moving your hands faster — it's about building a state where output accumulates without your hands at all. When I was laid off and my income went to zero, the first thing I rebuilt was this environment . Own an environment, not a workflow The essence of automation is constructing, exactly once, a mechanism where output keeps growing while you do nothing. That's precisely what daily.sh delivers: when the script finishes, ~/Desktop/ASMR/<date>_<theme>/ lands atomically with the video, thumbnail, youtube.md, and still image all in place. I just check it the next morning. Whether I step away mid-generation or I'm asleep, the files keep piling up. One line in the code embodies the whole philosophy: # 冪等性は「その日に1本でもあればskip」(1日1本・テーマ違

Your threat model has a hole shaped like your house. You run endpoint protection on your Mac. You have 2FA, passkeys, hardened browser, DNS filtering. You would never install random software from a forum. Then you walk into your living room that has 14 always-on microphones, 6 cameras, 3 devices that map your floor plan, and a router you have never audited, all running firmware you have never read. We need to talk. In cybersec we threat model laptops. We never threat model apartments. That is backwards. Your laptop leaves your house. Your house never leaves. If your home is compromised, every device you bring into it is compromised by proximity. Here is how I started threat modeling my apartment the same way I threat model my infra. It takes an afternoon and it will make your home actually sovereign. Step 1: Draw Trust Zones, Not Floor Plans Stop thinking in rooms. Start thinking in trust zones, exactly like network segmentation. I use 3 zones: Zone 0: The Dead Room. One room where no device can listen, watch, or transmit. No smart anything. No WiFi. No Bluetooth. This is where you think, talk for real, and store sensitive hardware. My bedroom is Zone 0. Nothing with a mic crosses the door. It has a mechanical door sweep and a faraday pouch for phones. Zone 1: The Clean Network. Your own network that you control. Your router, your Pi-hole, your own hotspot. Devices you have audited. This is where your work laptop lives. It never touches landlord WiFi, coffee shop WiFi, or that free "Apartment_5G" that is actually a $30 camera streaming 24/7. Zone 2: The Dirty Periphery. Everything else. Landlord's smart lock, smart thermostat, package room cameras, your smart TV, robot vacuum, Alexa, LED strips with mics, that random air freshener that is plugged in at waist height. Assume Zone 2 is hostile and logs everything. Most people live entirely in Zone 2 and call it cozy. That is why they get doxxed by their own house. If you want the full build for a Zone 0 room, what to r

Sudeep Das shares how DoorDash shifts from legacy one-shot predictions to an agentic recommendation platform. He discusses leveraging language-native consumer memory, RQ-VAE semantic IDs for catalog representation, and grounded search to dramatically boost relevance and conversion metrics. By Sudeep Das

I kept paying a monthly subscription for a cloud coding assistant while a 16GB M4 Mac mini sat on my desk idling most of the day. So I ran the obvious experiment: can a 16GB Mac mini run a coding assistant entirely offline — no code leaving the machine, no subscription — and is it actually usable for real work? Short answer: yes, with one hard constraint (RAM) and one soft one (context length). This article is the written version of the video above, with every command, config file, and benchmark number so you can reproduce it. Table of contents Why bother running locally The hardware constraint nobody mentions Step 1: Install Ollama Step 2: Pick a model that fits in 16GB Step 3: Run and verify Step 4: Wire it into VS Code Step 5: Tune Ollama for a 16GB box Benchmarks What it does well, what it doesn't Should you cancel Copilot? Why bother running locally Three reasons, in the order that actually mattered to me: Privacy. Client code, internal repos, anything under NDA — none of it leaves the machine. This is the one thing a hosted assistant cannot offer you at any price tier. Cost. A coding assistant subscription is roughly $100–240/yr depending on tier. The Mac mini was already bought. Offline. Flights, bad hotel wifi, coffee shop dead zones. The assistant just works. The reason not to: raw capability. The frontier hosted models are better at large multi-file reasoning, and it isn't close. More on that below. The hardware constraint nobody mentions On Apple Silicon, the GPU and CPU share one pool of unified memory. A model has to fit in that pool alongside macOS, your browser, VS Code, and whatever containers you're running . On a 16GB machine, macOS + a normal dev environment eats 6–8GB before you've loaded anything. That leaves you roughly 7–9GB of realistic headroom for the model. This single number determines everything else, and it's why "just run the 30B model" advice from people on 64GB machines doesn't transfer. By default macOS allows the GPU to use about 7

What happens when you stop picking a stack and let each protocol pick one for you. Every engineering team has a stack. Ours has seven, and we did not decide on any of them. Nevai is a self-hosted, end-to-end encrypted workspace built on Matrix. Part of it is a set of bridges — 25 of them — connecting Discord, Telegram, WhatsApp, Signal, iMessage, Messenger, Instagram, Slack, Google Chat, LINE, WeChat, KakaoTalk, Skype, GroupMe, SMS, email, IRC, XMPP, Zulip, Mattermost, Revolt, Mumble, QQ, X and LinkedIn into one place. We started out intending to standardise. We ended up with this: Language Bridges Go 12 TypeScript 5 Python 4 JavaScript 1 Kotlin 1 PLpgSQL 1 Slice 1 Nobody sat in a room and chose that distribution. It is what you get when the protocol decides. Go wins where the protocol was reverse-engineered WhatsApp, Signal, iMessage, Messenger, Instagram, Telegram, X, WeChat, QQ, Skype, LinkedIn, email. Twelve bridges, and the reason is the same every time: the mature libraries for those protocols are written in Go. That is not a claim about Go being a better language. It is a claim about where a decade of reverse-engineering effort happens to live. If you want to speak WhatsApp's protocol without running a browser session, you use what exists, and what exists is Go. Look at what leaks in around the edges and the picture gets sharper: Signal is 86% Go and 13% C — the C is libsignal, and you do not reimplement libsignal. iMessage is 96% Go and 3% Objective-C — because iMessage runs on macOS, and at some point you have to talk to the operating system in its own language. Those percentages are the honest part. A bridge is mostly your code and a small amount of somebody else's, and the small amount is usually the part that matters most. Python wins where the API is boring Google Chat, Zulip, KakaoTalk, LINE. Documented HTTP APIs, JSON in and JSON out, no protocol archaeology required. There is no performance argument here. These bridges are not throughput-bound; they

Unforgetful, the latest app from longtime indie developer Marco Arment, is designed to make reminders harder to ignore — or accidentally dismiss.

The Stop Killing Games movement faces an uphill battle.

Senator Warren questions whether Taylor Farms' influence swayed Trump admin.

One woman’s meth addiction was so bad, the only option left might have been brain surgery. Then a single session of noninvasive, focused ultrasound seemed to do what years of treatment could not.