Flox blog digest

The Flox blog, one entry per post, with the single fact worth repeating, quoted word for word, and a “use it when” line for field conversations. This file is part 1 of 4 and covers the first 23 of about 92 posts in the local corpus (sorted by file name, grouped here by year, newest first). Pull a proof point, then send the customer the original post.

This page is drawn from https://flox.dev/blog/ and each post linked below. Every post listed here was read in the local corpus on 2026-11-04; the corpus copy of each post is the text that was quoted.

How to use this page

• Quote the post, link the post. Blog posts are Flox’s own words; when a number matters, send the link so the customer reads it in context (https://flox.dev/blog/).
• Posts age. A post shows how a product worked on its date. Where a post and the docs disagree, the docs describe today’s product (https://flox.dev/docs/). Counts such as the size of the Catalog differ between posts of different dates (https://flox.dev/blog/intro-to-the-flox-cli-part-one-easy-environments/ and https://flox.dev/blog/flox-1.1-time-travel-across-100k-nix-packages/).
• Opinion is opinion. Several posts are position pieces by named authors, for example https://flox.dev/blog/byoa-needs-a-floor-that-floor-is-flox/. Quote them as the author’s view.
• Say: “Here is what the Flox team wrote, with the date.” Ask: “Which part of this matches the workload you are running?”

2026

2026-11-04: A Turnkey Toolkit for Agentic Development with Flox

• Fact: “Nearly 80 agents, orchestrators, sandboxes, memory layers, inference servers, and spec tools, each packaged as a ready-to-run Flox environment.” (https://flox.dev/blog/a-turnkey-toolkit-for-agentic-development-with-flox/). The TL;DR says it runs natively on macOS and Linux with no containers or VMs, and that agents get the flox, floxify and flox-debug skills.
• Use it when: an agent builder asks for something clone-and-run. It is the newest post in this part, dated 4 November 2026.

2026-10-29: Code and Its Runtime Should Travel Together

• Fact: “README files drift, and agents burn tokens reverse-engineering project setup.” (https://flox.dev/blog/code-and-its-runtime-should-travel-together/). Date taken from the “Published:” line (the DATE: field is blank). The post says the floxify skill creates the environment for an existing repo.
• Use it when: a repo owner asks how to stop setup docs going stale.

2026-07-29: Auto-Activation Is Now Native in Flox

• Fact: “whenever a directory contains a valid Flox environment, that environment starts up as soon as you cd into it” (https://flox.dev/blog/auto-activation-is-now-native-in-flox/). The post opens: “We noticed people hacking direnv so they could use it to auto-activate their Flox environments.” Services declared in the manifest start and stop with it.
• Use it when: a customer asks about direnv. Check the docs for the exact command and version before promising it [verify].

2026-07-15: AI Stack as Code: Define It Once, Run It Everywhere

• Fact: “One pattern composes four modular AI environments to create a reproducible, cross-platform, completely declarative AI RAG stack” (https://flox.dev/blog/ai-stack-as-code-define-it-once-run-it-anywhere/). A second pattern is a llama.cpp model-serving environment that answers questions about Flox using its docs and blog posts.
• Use it when: an ML team asks for reference patterns for RAG, embeddings or model serving as code.

2026-06-04: A Pattern for Local Dev: Runtime on the Host, Services in Containers

• Fact: “makes the project runtime a versioned artifact that teams can share, review, reproduce, and promote” (https://flox.dev/blog/a-pattern-for-local-dev-runtime-on-the-host-services-in-containers/). The pattern keeps language toolchains on the host in a Flox environment and runs PostgreSQL, Redis and similar services in containers. The post also walks through equivalent patterns for Nix and Guix.
• Use it when: a team says “we already use containers”. Say: “Keep them for the services; put the runtime in the environment.”

2026-05-01: Achieving CVE Remediation in an Era of Escalating Vulnerabilities

• Fact: “Instead of discovering vulnerable packages via after-the-fact scans” (https://flox.dev/blog/achieving-rapid-cve-remediation-in-an-era-of-escalating-vulnerabilities/). The post argues for a system of record for installed packages, with Flox and Nix giving a dependency graph that can be verified.
• Use it when: a security or platform team is drowning in CVE triage. Ask: “How do you answer which hosts have package X today?” Treat the claims as Flox positioning.

2026-03-18: BYOA Needs a Floor. That Floor Is Flox.

• Fact: “Wrap an unknown in a governance harness and you get a governed unknown.” (https://flox.dev/blog/byoa-needs-a-floor-that-floor-is-flox/). Jeremy Hogan responds to a Red Hat piece on “Bring Your Own Agent” and argues the missing layer is the environment the agent runs in.
• Use it when: an agent-platform team has guardrails and tracing but no control over runtime contents. It is a position piece, so quote it as the author’s view.

2026-03-16: Precision at Scale in Capital Markets: Deploying Hardened Flox NVIDIA CUDA Stacks in Minutes, Not Hours

• Fact: “By making the declarative environment, not the container image, the unit of change” (https://flox.dev/blog/deploying-hardened-flox-nvidia-cuda-stacks-in-minutes-not-hours/). Announces general availability of the “Flox CUDA Kickstart Program”, with a capital markets case study.
• Use it when: a GPU or finance customer asks about CUDA stacks, rollbacks and SBOMs.

2026-02-24: Enterprise Nix: It’s Time to Bring Nix to Work

• Fact: “Flox wraps Nix in familiar CLI semantics commands like flox install, activate, push etc.” (https://flox.dev/blog/enterprise-nix-its-time-to-bring-nix-to-work/). The TL;DR also says: “Nix is powerful but can be hard to adopt”.
• Use it when: a Nix champion is stuck as the only person who knows Nix.

2026-01-28: CVEs Are Now Being Exploited Faster Than You Can Respond

• Fact: “deterministic infrastructure for probabilistic workloads” (https://flox.dev/blog/cves-are-now-being-exploited-much-faster-than-you-can-respond/). The post calls for “input-addressed hashing, living SBOMs, and policy automation”.
• Use it when: a security buyer asks about SBOMs and response time. Opinion piece; use it for framing.

2025

2025-10-10: Create and Ship Reproducible Python Virtual Environments with Flox

• Fact: “venv module covers the basics, but it falls short of full reproducibility” (https://flox.dev/blog/create-and-ship-reproducible-development-environments-for-python-with-flox/). The post says Flox declares system libraries, compilers and GPU dependencies as well as Python packages.
• Use it when: a Python team uses venv or pip and gets “works on my machine” bugs.

2025-09-25: About our Series B

• Fact: “led by Addition, with participation from NEA, the D. E. Shaw group, Hetz Ventures, and Illuminate Financial” (https://flox.dev/blog/about-our-series-b/). Ron Efroni announces the Series B round; the post also tells the founding story, that he saw in Nix “software environments that travel as-is from local development through CI to production”.
• Use it when: a buyer asks who funds Flox and how stable the company is. Send the post; it is the CEO’s own account.

2024

2024-09-09: A Real World Rust Project with Flox

• Fact: “proctrace records process lifecycle events (fork, exec, setpgid, etc) for the process tree of a user-provided command” (https://flox.dev/blog/a-real-world-rust-project-with-flox/). proctrace is a profiler written by Zach Mitchell to debug and inspect Flox; the post shows how the [install] section of the manifest covers a mixed-language, cross-platform project.
• Use it when: a Rust developer asks what Flox adds beyond cargo (system libraries, other languages, other tools).

2024-08-22: Flox 1.3: Simplified Service Management with Flox

• Fact: “Starting and stopping services is now a cinch, because Flox takes care of all the background setup and teardown tasks for you.” (https://flox.dev/blog/flox-1.3-simplified-service-management-with-flox/). The examples use a local Ollama LLM server and PostgreSQL.
• Use it when: a customer runs local nginx, Redis or Postgres by hand.

2024-08-19: Conflict Resolution Made Easy with Package Groups in Flox

• Fact: “isolate fussy or finicky packages in distinct Package Groups” (https://flox.dev/blog/conflict-resolution-made-easy-with-package-groups-in-flox/). The example is a traveling Kubernetes toolkit where kubectl, helm, stern and k9s each get their own pkg-group.
• Use it when: a customer hits “Flox refused to install that version”. Answer: split it into its own package group.

2024-07-24: Extending Flox with Nix Flakes

• Fact: “The Flox Catalog has almost everything, with 3+ years of history and more than 1 million package/version combinations.” (https://flox.dev/blog/extending-flox-with-nix-flakes/). You add a flake by referencing a flake.nix in the manifest.toml.
• Use it when: a customer needs a package or override the Catalog lacks.

2024-07-12: Extreme $HOME Makeover with Flox

• Fact: “By pushing my default environment to FloxHub, I can easily pull and install it on new systems.” (https://flox.dev/blog/extreme-home-makeover-with-flox/). The idea is one default environment in $HOME, carried between machines.
• Use it when: someone wants a consistent personal toolset across macOS and Linux.

2024-07-02: A Very Short Introduction to Layering in Flox

• Fact: “upper layers in the stack inherit the features and capabilities of the layers beneath them” (https://flox.dev/blog/a-very-short-introduction-to-layering-in-flox/). The worked example activates a default environment from $HOME, then a project environment on top of it.
• Use it when: a customer wants small, use-case-specific environments combined instead of one giant one.

2024-06-25: Flox 1.1: Time Travel Across 100k+ Nix Packages

• Fact: “over one million unique package/version combinations” (https://flox.dev/blog/flox-1.1-time-travel-across-100k-nix-packages/). The title says 100k+ but the body says over one million; quote the body figure and note the mismatch.
• Use it when: you need the date of the Catalog expansion to daily Nixpkgs-unstable updates.

2023

2023-05-08: Contributing to Nixpkgs

• Fact: “one of the largest package recipe repositories in existence, Nixpkgs has many examples to learn from” (https://flox.dev/blog/contributing-to-nixpkgs/). A how-to for a first Nixpkgs contribution; it does not cover writing the Nix expression itself.
• Use it when: a community member wants to add a package upstream.

2023-02-07: Announcing the Flox Open Beta

• Fact: “release the flox CLI beta to the public as an open source project” (https://flox.dev/blog/announcing-the-flox-open-beta/). The same post announces a Series A round led by NEA.
• Use it when: you need the date the CLI went public as open source: 7 February 2023.

2022

2022-11-04: Building the Ladder

• Fact: “Adoption at larger scale cannot be solved with a single feature” (https://flox.dev/blog/building-the-ladder-flox-at-nixcon/). Tom Bereknyei’s NixCon 2022 talk sets out the “4 C’s”: Community, Convenience, Collaboration, and Control.
• Use it when: you want the original roadmap vocabulary (Catalog, declarative profiles, publish, containerize) in the company’s own words.

2022-10-13: Flox, Nix for Simplicity & Scale

• Fact: “Seamlessly create new polyglot developer environments” (https://flox.dev/blog/announcing-flox/). The first announcement. The stated mission: “make Nix’s superpowers more accessible to a broader audience of developers, teams and enterprises”.
• Use it when: someone asks why Flox exists at all. It is the original, dated statement of intent, written for the beta.

Full list continued (posts 24 to 46 of the sorted corpus list)

This part continues part 1. Entries are grouped by year, newest first; each has the date, the post, one fact quoted word for word, and when to use it. Old posts describe the product as it was then, so check the docs before you promise a customer anything current (https://flox.dev/docs/).

2026

2026-10-19: Flox Catalog Login Requirement Starts October 20: What You Need to Know

• Fact: “Starting October 20, 2026, installing, upgrading, or resolving packages from the Flox Catalog requires a free FloxHub account.” (https://flox.dev/blog/flox-catalog-login-requirement-what-you-need-to-know/). Date taken from the “Published:” line (DATE: is blank). Search and show stay public, and an environment with a committed lockfile activates without a login.
• Use it when: a customer asks about the login change, or about CI. This is a policy post; confirm current status in the docs.

2026-10-01: Focusing on the Code, Not the Cruft

• Fact: “Its verification loop caught missing dependencies and platform quirks a manual setup could easily miss, and fixed them.” (https://flox.dev/blog/focusing-on-the-code-not-the-cruft/). Date from the “Published:” line. Justin Castilla tests the flox and floxify skills with Claude Code, producing a six-service Mastodon dev stack.
• Use it when: a developer wants to see agent skills build an environment from an existing repo.

2026-08-03: Flox Account Tokens for People and Machines

• Fact: “One credential for a person, one for a machine.” (https://flox.dev/blog/flox-account-tokens-for-people-and-machines/). Pipelines supply the service account token through FLOX_FLOXHUB_TOKEN.
• Use it when: a platform team asks how CI authenticates to FloxHub without a person’s login.

2026-03-26: Flox and Containers: A Perfect Pattern for Local Development

• Fact: “Flox environments provide the project runtime” (https://flox.dev/blog/flox-and-containers-a-perfect-pattern-for-local-development/). Customer Ryan Schlesinger of detaso uses this with a Rails app and PostgreSQL; Flox pairs with OrbStack for containers on macOS.
• Use it when: a customer compares Flox with dev containers. Companion to the 2026-06-04 post.

2026-03-16: GPU-Optimized PyTorch Builds Made Easy with Flox and Nix

• Fact: “Generic PyTorch pulls in support for almost a dozen different CUDA architectures, plus Intel- and Apple-specific GPU and CPU builds.” (https://flox.dev/blog/gpu-optimized-pytorch-builds-made-easy-with-flox-and-nix/). The post pitches smaller, targeted builds published to your own Catalog.
• Use it when: a customer wants smaller wheels or images for production inference.

2026-01-10: Reproducible NVIDIA CUDA Environments Across Your SDLC

• Fact: “You can even install separate, conflicting versions of CUDA dependencies side-by-side on the same system, at the same time” (https://flox.dev/blog/get-nvidia-cuda-stacks-that-travel-across-your-sdlc-with-flox/). Example: the latest CUDA Toolkit for PyTorch alongside CUDA Toolkit 12.4 for TensorFlow.
• Use it when: an ML team juggles CUDA versions.

2025

2025-06-26: Introducing Flox Build and Publish

• Fact: “you can use flox publish to package and publish not just your build artifacts but all required runtime dependencies to your private Flox Catalog” (https://flox.dev/blog/introducing-flox-build-and-publish/). The post says all output of flox build goes to $out.
• Use it when: a team wants to ship its own packages.

2025-06-10: Flox Named to Redpoint’s InfraRed 100

• Fact: “This is a round-up of 100 visionary companies building the next layer of cloud infrastructure.” (https://flox.dev/blog/flox-named-to-redpoints-infrared-100/). Ron Efroni writes that Flox debuted on the annual list.
• Use it when: a buyer wants third-party recognition. Weak evidence; say it is a list, not a benchmark.

2025-04-18: Flox Named Exclusive Media Sponsor of the Rock Bottom Curling Club’s 2025 Season

• Fact: “first official foray into the world of sports partnerships” (https://flox.dev/blog/flox-named-exclusive-media-sponsor-of-the-rock-bottom-curling-clubs-2025-season/). A press release; the club connection is Flox engineer Zach Mitchell.
• Use it when: small talk, or a customer asks about the company’s culture. Not a product proof point.

2025-03-18: Get Your Preferred Secrets Manager in a Secure Cross-Platform CLI Toolkit

• Fact: “retrieve credentials ephemerally, at runtime, injecting them only as needed” (https://flox.dev/blog/get-your-preferred-secrets-manager-in-a-portable-cross-platform-cli-toolkit/). The workflow spans local dev, GitHub and AWS.
• Use it when: a security reviewer objects to credentials in files or keyrings.

2025-02-18: Gonna be at SCALE 22x? Beam on to Planet Nix!

• Fact: “Planet Nix, the annual gathering of Nix users and developers” (https://flox.dev/blog/gonna-be-at-scale-22x-beam-onto-planet-nix/). Dates: “March 5th through 7th”, with a fireside chat between Kelsey Hightower and NixOS Foundation President Ron Efroni.
• Use it when: dating an event; context for community ties.

2025-02-04: Get DeepSeek R1 on Your Laptop with Ollama and Flox

• Fact: “shockingly simple to run not just DeepSeek R1, but dozens of other large language models (LLM) locally” (https://flox.dev/blog/get-deepseek-r1-on-your-laptop-with-ollama-and-flox/). The environment adds nextjs-ollama-llm-ui for a ChatGPT-like browser front end.
• Use it when: someone wants local LLMs with no setup.

2024

2024-12-05: Flox and AWS: Taking the Chaos Out of Secrets Management

• Fact: “short-term secrets as environment variables to an ephemeral 1Password environment inside the Flox environment” (https://flox.dev/blog/flox-and-aws-taking-the-chaos-out-of-secrets-management/). It pairs 1Password with AWS CLI v2 via 1Password’s op run.
• Use it when: a team shares AWS credentials in dotfiles.

2024-12-02: Flox and AWS: Building, Testing, and Deploying Lambda Functions with Flox and AWS SAM

• Fact: “Using Flox, you can define both your code and runtime in the same GitHub, GitLab, or CodeCommit repo.” (https://flox.dev/blog/flox-and-aws-building-testing-and-deploying-lambda-functions-with-flox-and-aws-sam/). The walk-through installs the AWS CLI and AWS SAM from the Catalog and containerizes the function.
• Use it when: an AWS shop builds Lambda functions.

2024-11-22: Flox and Teams: Managing Your Code and Your Runtime Environment in Just One Place

• Fact: “you can define both your project and its runtime as code, enabling features and dependencies to be reviewed, tested, and deployed together” (https://flox.dev/blog/flox-and-teams-managing-your-code-and-your-runtime-environment-in-just-one-place/). The scenario adds a themed feature, with a front-end tool, to a customer portal.
• Use it when: a team lead asks how a runtime change gets reviewed like code.

2024-11-15: Flox and Teams: Using Shared Flox Environments

• Fact: “The beauty of using the flox activate -r command is that everyone on your team always uses exactly the same version of the environment.” (https://flox.dev/blog/flox-and-teams-using-shared-flox-environments/). Platform engineers push github-shell and aws-tools environments to FloxHub with flox push.
• Use it when: a platform team wants one shared toolset.

2024-11-07: Flox and Teams: Onboarding Made Easy with GitHub and Flox

• Fact: “With flox activate -r, teams get the same version of a FloxHub environment” (https://flox.dev/blog/flox-and-teams-onboarding-made-easy-with-github-and-flox/). The same sentence says to run flox pull -r to update to the latest version.
• Use it when: an engineering manager measures time to first commit for new hires.

2024-09-26: Integrating Flox with CI for Consistent, Reproducible Dev Environments

• Fact: “flox/install-flox-action and flox/activate-action to run, test, and validate your Flox environments during CI runs” (https://flox.dev/blog/integrating-flox-with-ci-for-consistent-reproducible-dev-environments/). Focuses on GitHub Actions; CircleCI and GitLab are pointed to the docs.
• Use it when: a team asks how Flox runs in CI.

2024-09-05: Hassle-Free Cross-Platform Dev with Flox

• Fact: “Flox environments always run platform-optimized, using native binaries and libraries, with no virtualization required.” (https://flox.dev/blog/hassle-free-cross-platform-dev-with-flox/). The post states Flox is not a hypervisor or emulator, so software not built for an OS or architecture cannot be made to run there.
• Use it when: a customer assumes Flox emulates other platforms. Be honest about that limit.

2024-03-26: Intro to the Flox CLI, Part One: Easy Environments

• Fact: “which is based on Nixpkgs and contains over 215,000 packages” (https://flox.dev/blog/intro-to-the-flox-cli-part-one-easy-environments/). Dated March 2024; later posts cite over one million package/version combinations, so the figures count different things [verify].
• Use it when: a first demo: install charasay with flox search without touching the system.

2024-03-26: Intro to the Flox CLI, Part Three: Cloning, Pushing, and Pulling

• Fact: “This will send the environment to FloxHub, where you can view it on the web.” (https://flox.dev/blog/intro-to-the-flox-cli-part-three-cloning-pushing-and-pulling/). It uses flox push on a small cows environment.
• Use it when: a demo of sharing an environment.

2023

2023-01-31: Hash Collision

• Fact: “No, because Nix leverages a custom format called Nix Archive (NAR) for archiving source trees” (https://flox.dev/blog/hash-collision/). About GitHub changing its archive format and why Nixpkgs was not affected.
• Use it when: a customer asks about supply-chain integrity and Nix hashing.

2023-01-01: Happy New Year!

• Fact: “Our team grew to over a dozen people, globally distributed.” (https://flox.dev/blog/happy-new-year/). A year-end note for 2022.
• Use it when: historical company size. Do not use it as a current headcount.

Blog digest, part 3: containers, AI infrastructure, supply chain and releases (2022 to 2026)

Each entry has the date from the post, the post, one fact copied verbatim from it, and a “use it when” line. The posts here run from a 2022 Nix explainer to August 2026 release notes. They are grouped by period and listed newest first inside each group. Some counts differ between posts (for example the Nixpkgs recipe count), so quote the post you cite and its date, not a blended number.

2026: Kubernetes, AI serving, supply chain and releases

• 2026-08-13 Making Flox Better for People and Machines. Fact: “PATs represent individual users, while SATs give CI, agents, and other automation their own FloxHub identity and access level.” (https://flox.dev/blog/making-flox-better-for-people-and-machines/). The same post says Flox v.1.14.0 shipped personal access tokens and service account tokens, and that v1.14.1 shipped that week (https://flox.dev/blog/making-flox-better-for-people-and-machines/). Use it when: a customer asks how CI or an agent authenticates to FloxHub without an interactive login.
• 2026-07-21 One Tool, Every Language: Declarative Dev Environments. Fact: “This article introduces a hardened set of 16 language-specific declarative dev environments.” (https://flox.dev/blog/one-tool-every-language-declarative-dev-environments/). They can be used singly or composed into polyglot stacks (https://flox.dev/blog/one-tool-every-language-declarative-dev-environments/). Use it when: a platform team has a polyglot monorepo and asks how to hand out toolchains as code.
• 2026-06-22 Mitigating Shai-Hulud Attacks with Hermetic Builds. Fact: “The original September 2025 Shai-Hulud campaign compromised 500+ npm packages, and follow-on waves have since pushed the total far higher.” (https://flox.dev/blog/mitigating-shai-hulud-attacks-with-hermetic-builds/). The post frames the risk as a build environment that holds secrets and network access at the same time (https://flox.dev/blog/mitigating-shai-hulud-attacks-with-hermetic-builds/). Use it when: a security-minded buyer asks about npm supply chain worms. Read the post for the actual build-isolation mechanism before promising specifics.
• 2026-05-27 Platform Teams and the Challenge of Works-on-My-Machine. Fact: “But there is an Option 3: standardize what the project needs without dictating how every engineer works.” (https://flox.dev/blog/platform-teams-and-the-challenge-of-works-on-my-machine/). Options 1 and 2 are strict boundaries (dev containers, VMs, cloud dev shells) or leaving local dev to each team (https://flox.dev/blog/platform-teams-and-the-challenge-of-works-on-my-machine/). Use it when: pitching a platform team that is torn between locking down dev machines and letting drift happen.
• 2026-05-23 Radio Free Flox for May 23rd, 2026. Fact: “In every case, Flox now tracks upstream releases and publishes updated packages within hours.” (https://flox.dev/blog/radio-free-flox-for-may-23rd-2026/). This first weekly episode lists new catalog packages including Amp, DeepSeek TUI, GitHub Copilot CLI, Gemini CLI and Mistral Vibe (https://flox.dev/blog/radio-free-flox-for-may-23rd-2026/). Use it when: someone asks how fast new AI coding tools show up in the Flox Catalog. Check the catalog itself for current packages.
• 2026-03-16 Production Model Serving: Triton, vLLM, and llama.cpp. Fact: “The Flox Triton Server environment runs NVIDIA Triton v2.66.0 with precompiled backends for Python, ONNX Runtime, NVIDIA TensorRT, and vLLM v0.16.0.” (https://flox.dev/blog/production-model-serving-using-nvidia-triton-vllm-llamacpp-with-flox/). The post makes the declarative environment, not the OCI image, the unit of promotion (https://flox.dev/blog/production-model-serving-using-nvidia-triton-vllm-llamacpp-with-flox/). Use it when: an ML platform team asks for a concrete model-serving environment. Versions are as of the post date.
• 2026-03-16 Reproducible, Auditable ML/AI for Capital Markets with Flox. Fact: “A declarative environment spec becomes the unit of promotion across the SDLC, from local dev to prod” (https://flox.dev/blog/reproducible-auditable-ml-ai-for-capital-markets-with-flox/). The post also lists safer upgrades and reversions via versioned environment definitions (https://flox.dev/blog/reproducible-auditable-ml-ai-for-capital-markets-with-flox/). Use it when: a finance or regulated-industry customer needs an audit and rollback story for ML workloads.
• 2026-03-03 PlanetNix 2026: Is Now the Time for Nix?. Fact: “Get SBOMs for every package tracked by the Flox Catalog: more than 190,000 distinct Nixpkgs packages spanning millions of historical package-version combinations.” (https://flox.dev/blog/planetnix-2026-is-now-the-time-for-nix/). The post says catalog SBOMs are free for all users and environment SBOMs are for commercial users (https://flox.dev/blog/planetnix-2026-is-now-the-time-for-nix/). Use it when: a customer asks about SBOMs and which tier gets which. Check the pricing page for the current split.
• 2026-02-24 Kubernetes, Uncontained, Explained. Fact: “Even better, it means the set of store paths is the SBOM.” (https://flox.dev/blog/kubernetes-uncontained-explained-unlocking-faster-more-reproducible-deployments-on-k8s/). The post describes a Flox-maintained containerd shim that pulls the versioned environment from FloxHub (https://flox.dev/blog/kubernetes-uncontained-explained-unlocking-faster-more-reproducible-deployments-on-k8s/). Use it when: a Kubernetes team asks how imageless pods and SBOMs fit together. A November 2025 version of this article is digested in the next file.
• 2026-01-03 Nixpkgs: The Big Recipe Book of Open Source. Fact: “Nixpkgs is a massive repository with over 120,000 open-source software recipes.” (https://flox.dev/blog/nixpkgs-the-big-recipe-book-of-open-source/). The post also states that Flox sources from Nixpkgs and adds semantic versioning and branch tracking (https://flox.dev/blog/nixpkgs-the-big-recipe-book-of-open-source/). Use it when: someone asks what is under the Flox Catalog. This 120,000 figure differs from the 190,000 in the PlanetNix post above; cite each with its own date.

2025: containers, SDLC, packaging and agents

• 2025-11-25 Reproducible Builds Made Simple with Nix and Flox. Fact: “But Flox is also a reproducible build system.” (https://flox.dev/blog/reproducible-builds-made-simple-with-nix-and-flox/). It describes two build modes, manifest builds and Nix expression builds, and says a manifest build “is only a Nix shim around your existing recipes” so build-time reproducibility is not guaranteed (https://flox.dev/blog/reproducible-builds-made-simple-with-nix-and-flox/). Use it when: a customer asks about flox build and flox publish and how strict the reproducibility guarantee is for each mode.
• 2025-09-26 Agentic Development Environments with Nix and Flox. Fact: “In fact, Flox makes it possible to run conflicting versions of software dependencies in the same environment, on the same system, at the same time.” (https://flox.dev/blog/next-level-agentic-development-with-flox/). The post suggests giving agents a Flox-aware FLOX.md or CLAUDE.md (https://flox.dev/blog/next-level-agentic-development-with-flox/). Use it when: a team uses Cursor, Claude Code or Codex and asks why Flox helps agents waste less time on dependency conflicts.
• 2025-08-26 Composable Dev Environments: Layering and Composition in Flox. Fact: “Layering adds tools dynamically at runtime.” (https://flox.dev/blog/layering-and-composing-flox-environments/). Its companion line: “Composition merges environments declaratively at build.” (https://flox.dev/blog/layering-and-composing-flox-environments/). Use it when: a customer asks the difference between stacking activated environments and composing with include.
• 2025-08-08 Package Managers and Package Management: A Guide for the Perplexed. Fact: “apt and other system package managers debuted almost 30 years ago” (https://flox.dev/blog/package-managers-and-package-management-a-guide-for-the-perplexed/). The post uses a managed-care analogy for why traditional managers do not always give you the versions you ask for (https://flox.dev/blog/package-managers-and-package-management-a-guide-for-the-perplexed/). Use it when: a prospect asks why not just apt, brew or conda, and you want a framing story.
• 2025-05-19 Reclaiming the SDLC. Fact: “Fragmentation is the defining characteristic of software development today.” (https://flox.dev/blog/reclaiming-the-sdlc/). The argument is that CI/CD standardizes patterns but not how teams actually work (https://flox.dev/blog/reclaiming-the-sdlc/). Use it when: opening a leadership conversation about tooling sprawl across dev, CI and production.
• 2025-02-25 Nix and Docker containers: Why Not Both?. Fact: “Nix and containers solve different problems but work best together.” (https://flox.dev/blog/nix-and-containers-why-not-both/). The post says Nix can build deterministic OCI images deployable with any OCI-compatible tooling (https://flox.dev/blog/nix-and-containers-why-not-both/). Use it when: a Docker-first team hears Nix and assumes it replaces containers.
• 2025-01-29 Is Flox an Alternative to Containers?. Fact: “Flox environments and containers have few areas of overlap, and their respective boundaries are mostly well-defined.” (https://flox.dev/blog/is-flox-an-alternative-to-containers/). It is a Q&A with Flox Vice President of Engineering Michael Stahnke that argues for both/and, not either/or (https://flox.dev/blog/is-flox-an-alternative-to-containers/). Use it when: the objection is we already use containers, the most common first reaction.

2022 to 2024: Nix background and early CLI guides

• 2024-08-08 Mastering Hooks and Profiles for Reproducible Flox Environments. Fact: “Anything you put into [hook] runs whenever your Flox environment is activated.” (https://flox.dev/blog/mastering-hooks-and-profiles-for-reproducible-flox-environments/). The post also warns what hooks should not be used for and how misuse can cause production headaches (https://flox.dev/blog/mastering-hooks-and-profiles-for-reproducible-flox-environments/). Use it when: a customer’s activation is slow or surprising and you need the hook versus profile explanation.
• 2024-07-30 Making Ruby Projects Easier to Share. Fact: “But the bane of my existence is implicit dependencies from RubyGems.” (https://flox.dev/blog/making-ruby-projects-easier-to-share/). The author, Michael Stahnke, walks through nokogiri and native-extension gems that a Gemfile cannot describe (https://flox.dev/blog/making-ruby-projects-easier-to-share/). Use it when: a Ruby or Rails shop complains about native library setup on every new laptop.
• 2024-07-10 ML Modeling with FLAIM and Hugging Face Diffusers. Fact: “A solid one-third of professional developers use MacOS, more than six times the overall market share of that platform.” (https://flox.dev/blog/ml-modeling-with-flaim-and-hugging-face-diffusers/). The post attributes the data to StackOverflow’s 2023 Developer Survey and uses it to argue against containerizing Stable Diffusion (https://flox.dev/blog/ml-modeling-with-flaim-and-hugging-face-diffusers/). Use it when: an ML team on MacBooks asks why containers are a poor fit for Metal GPU work.
• 2024-03-26 Intro to the Flox CLI, Part Two: Aliases, Vars, and Hooks. Fact: “Every Flox environment has a manifest: a block of text that defines the environment and can - by itself - be used to recreate it.” (https://flox.dev/blog/intro-to-the-flox-cli-part-two-aliases-vars-and-hooks/). It walks through the vars, profile and options sections of the early manifest (https://flox.dev/blog/intro-to-the-flox-cli-part-two-aliases-vars-and-hooks/). Use it when: you want an early-2024 beginner walkthrough of the manifest. The sample manifest is dated; check the docs for current syntax.
• 2023-10-12 NixCon 2023: Recap & Videos. Fact: “There were talks from five flox team members.” (https://flox.dev/blog/nixcon-2023-recap-videos/). The post notes that Flox CEO Ron Efroni joined Eelco Dolstra for a Nix Foundation status update (https://flox.dev/blog/nixcon-2023-recap-videos/). Use it when: a customer asks how involved Flox is in the Nix community.
• 2022-06-12 Nix: Pure Genius. Fact: “software packaged with Nix runs the same on any Linux distro and in any context.” (https://flox.dev/blog/nix-pure-genius/). The post explains side-by-side installs at checksum-derived paths and self-contained dependency closures (https://flox.dev/blog/nix-pure-genius/). Use it when: a Linux-savvy engineer asks why Nix packages are portable without containers.

Blog digest, part 4: language guides, local AI, CUDA and standardized environments (2022 to 2026)

Each entry has the date from the post, the post, one fact copied verbatim from it, and a “use it when” line. This half of the archive is mostly practical guides: per-language quick starts, local model serving, CUDA, Kubernetes and the case for standardized dev environments. Groups run newest first. Older guides show the CLI as it was at the time, so check the docs before quoting commands or output as current.

2026: local AI, Slurm, standardized environments and flox run

• 2026-09-11 Sometimes You Just Need jq. Fact: “The flox run subcommand finds the package that provides the requested program and runs it without requiring you to create or modify a Flox environment.” (https://flox.dev/blog/sometimes-you-just-need-jq/). The post also announces pre-built secrets integrations built on the experimental environment-plugin capability introduced in Flox v1.14 (https://flox.dev/blog/sometimes-you-just-need-jq/). Use it when: someone wants to try one package without creating an environment, or asks how secrets retrieval fits in.
• 2026-06-15 Training nanoGPT on Slurm with a Nix-Pinned Environment. Fact: “This article describes a pattern for creating reproducible runtime environments for ML/AI using declared, graph-backed environments based on Nix and Flox.” (https://flox.dev/blog/training-nanogpt-on-slurm-with-a-nix-pinned-environment/). The opening scenario is a model that trains on a MacBook and then fails on a GPU cluster (https://flox.dev/blog/training-nanogpt-on-slurm-with-a-nix-pinned-environment/). Use it when: a research team hands work from laptops to Slurm and keeps hitting CUDA and library mismatches.
• 2026-05-21 Run Frontier Models Anywhere with DeepSeek TUI. Fact: “DeepSeek TUI rocketed to almost 33,000 stars on GitHub within two weeks of launching.” (https://flox.dev/blog/run-frontier-models-anywhere-with-deepseek-tui/). The post shows it running against local Qwen 3.6 models through Ollama or oMLX, either from a Flox environment or a Nix flake (https://flox.dev/blog/run-frontier-models-anywhere-with-deepseek-tui/). Use it when: a customer wants a local coding-agent harness with no cloud model dependency.
• 2026-05-19 Works on My Machine: A Platform Problem. Fact: “Flox environments run in subshells, not in containers” (https://flox.dev/blog/works-on-my-machine-a-platform-problem/). The post uses Fellow.ai, whose CTO Sam Cormier-Iijima is quoted, as the customer example (https://flox.dev/blog/works-on-my-machine-a-platform-problem/). Use it when: you need a named customer story for the works-on-my-machine pain. Confirm with Flox what Fellow.ai allows you to repeat before naming it in a sales deck.
• 2026-05-14 Standardized Development Environments Explained. Fact: “It argues that declarative, graph-backed standardized development environments achieve comparable reproducibility without restricting local autonomy or impeding developer and team velocity.” (https://flox.dev/blog/standardized-development-environments-explained/). It compares dev containers, cloud dev shells and declarative environments on how much control each exerts locally (https://flox.dev/blog/standardized-development-environments-explained/). Use it when: a buyer is comparing Flox with dev containers or cloud workspaces. It is the longest comparison in the archive.
• 2026-04-21 Run GPU-Accelerated Frontier Coding Models Locally on Your Laptop. Fact: “This means a 32 GB MacBook Pro can run models that require a GPU with 32GB of VRAM” (https://flox.dev/blog/run-gpu-accelerated-frontier-coding-models-locally-on-your-laptop/). The post is candid that NVIDIA RTX GPUs are still much faster than Macs for local inference when the model fits in VRAM (https://flox.dev/blog/run-gpu-accelerated-frontier-coding-models-locally-on-your-laptop/). Use it when: a customer asks about local models on MacBooks, and keep the caveat with the headline.
• 2026-04-15 Reproducible Flox Environments for the First and the Last Mile of AI. Fact: “ML/AI teams can also run CUDA-accelerated Flox runtime environments on Slurm clusters during model training.” (https://flox.dev/blog/reproducible-flox-environments-for-the-first-and-the-last-mile-of-ai/). The same post covers running CUDA workloads “uncontained” on Kubernetes (https://flox.dev/blog/reproducible-flox-environments-for-the-first-and-the-last-mile-of-ai/). Use it when: an ML platform team wants one pinned runtime from Slurm training to Kubernetes serving.
• 2026-02-05 Create Portable, Reproducible Node.js Environments With Flox. Fact: “Version-control your manifest.toml for team consistency” (https://flox.dev/blog/using-flox-to-create-portable-reproducible-nodejs-environments/). The post says it works on Linux, macOS and Windows with WSL2, on ARM and x86 (https://flox.dev/blog/using-flox-to-create-portable-reproducible-nodejs-environments/). Use it when: a JavaScript team asks for a five-minute starting point.
• 2026-01-30 Reproducible Dev Environments in Your Workflow with Flox and VS Code. Fact: “This means Flox environments always start pre-activated” (https://flox.dev/blog/reproducible-dev-environments-in-your-workflow-with-flox-and-vs-code/). The post says agent-spawned shells inherit the environment, so agents need to know nothing about Flox (https://flox.dev/blog/reproducible-dev-environments-in-your-workflow-with-flox-and-vs-code/). Use it when: a VS Code shop asks whether test runners and agents get the right PATH automatically.

2025: AI-assisted onboarding, Kubernetes, CUDA and Python

• 2025-12-12 Reproducible Dev Environments with AI Agents: Part 2. Fact: “Today, with an AI assistant doing the work, Floxifying most any project repo takes just a few minutes.” (https://flox.dev/blog/reproducible-development-environment-in-any-repo-part-2/). It tests the idea on two real public repos, Node-RED and n8n (https://flox.dev/blog/reproducible-development-environment-in-any-repo-part-2/). Use it when: someone has an existing repo and wants proof that migration is quick.
• 2025-12-12 Reproducible Dev Environments with AI Agents: Part 1. Fact: “AI agents can turn any repo into a reproducible Flox environment in minutes, backed by access to millions of historical package versions.” (https://flox.dev/blog/reproducible-development-environment-in-any-repo-part-1/). The post says Flox’s MCP server gives an agent the context it needs to work with Flox (https://flox.dev/blog/reproducible-development-environment-in-any-repo-part-1/). Use it when: demoing the prompt the agent to floxify this repo flow.
• 2025-11-10 Kubernetes Uncontained: Faster Deploys on K8s. Fact: “Instead of pulling digest-pinned images, you simply reference declarative Flox environments in your Pod templates.” (https://flox.dev/blog/with-kubernetes-uncontained-flox-unlocks-faster-more-reproducible-workloads-on-k8s/). It lists benefits including no registry push and pull cycles for updates (https://flox.dev/blog/with-kubernetes-uncontained-flox-unlocks-faster-more-reproducible-workloads-on-k8s/). Use it when: the first mention of imageless Kubernetes; the longer February 2026 explainer is in the previous file.
• 2025-09-10 The Flox Catalog Now Contains NVIDIA CUDA. Fact: “Flox is one of four commercial open source vendors” licensed to redistribute precompiled, prepatched packages that include NVIDIA’s CUDA binaries and libraries (https://flox.dev/blog/the-flox-catalog-now-contains-nvidia-cuda/). The post also says building a full CUDA-accelerated ML stack from source “could take days” (https://flox.dev/blog/the-flox-catalog-now-contains-nvidia-cuda/). Use it when: a GPU customer asks why Flox saves build time and whether the CUDA redistribution is licensed.
• 2025-07-29 Reproducible Development Environments for Python with Flox. Fact: “each dependency is referenced by a unique content fingerprint: a cryptographic (SHA256) hash.” (https://flox.dev/blog/reproducible-python-development-environments-with-flox/). It shows flox init on both new projects and an existing one (https://flox.dev/blog/reproducible-python-development-environments-with-flox/). Use it when: explaining how Flox gets to “byte for byte” reproducibility in plain terms.
• 2025-06-10 Run ComfyUI Anywhere With Flox. Fact: “This environment works from within a checked out clone of ComfyUI.” (https://flox.dev/blog/run-comfyui-anywhere-with-flox/). The setup is a git clone of ComfyUI followed by flox activate -r flox/ComfyUI -s (https://flox.dev/blog/run-comfyui-anywhere-with-flox/). Use it when: a hobbyist or ML user wants a first FloxHub environment to activate remotely.
• 2025-03-26 The Experienced Novice Dives into Nix. Fact: “Given how most teams ship software, something else always begets something else.” (https://flox.dev/blog/the-experienced-novice-dives-into-nix/). Michael Stahnke describes coming to Nix as an experienced packaging engineer and finding it hard (https://flox.dev/blog/the-experienced-novice-dives-into-nix/). Use it when: a skeptic says Nix is too hard; this is a first-person answer from a Flox leader.

2022 to 2024: origins, language guides and FloxHub

• 2024-12-23 Setting Up a New Laptop Made Easy with Flox. Fact: “This means you can replicate your preferred apps, tools, settings, and workflows across all your devices” (https://flox.dev/blog/setting-up-a-new-laptop-made-easy-with-flox/). The post’s one-liner is flox activate -r followed by your username and /default (https://flox.dev/blog/setting-up-a-new-laptop-made-easy-with-flox/). Use it when: a prospect asks about dotfiles, laptop onboarding or keeping a personal environment in sync.
• 2024-10-10 Using Flox to Create Portable, Reproducible Go Environments. Fact: “Flox makes it easy to create portable, reproducible Golang (Go) dev environments that run the same way on Linux, macOS, and Windows (with WSL2), across both ARM and x86 architectures.” (https://flox.dev/blog/using-flox-to-create-portable-reproducible-go-environments/). It also covers existing projects with a go.mod file (https://flox.dev/blog/using-flox-to-create-portable-reproducible-go-environments/). Use it when: a Go team with cgo or mixed-language builds asks about onboarding.
• 2024-09-18 Write Once, Take Anywhere $HOME Away from Home with FloxHub. Fact: “By flox push-ing an environment to FloxHub, you can make it available to all of your teammates.” (https://flox.dev/blog/write-once-take-anywhere-home-away-from-home-with-floxhub/). The post also shows FloxHub’s built-in manifest editor, which validates changes in real time (https://flox.dev/blog/write-once-take-anywhere-home-away-from-home-with-floxhub/). Use it when: demoing push and pull and why FloxHub exists.
• 2024-09-10 Using Flox to Create Portable, Reproducible Python Environments. Fact: “Flox makes it easy to create portable, reproducible Python environments that run the same way on Linux, macOS, and Windows (with WSL2), across both ARM and x86 architectures.” (https://flox.dev/blog/using-flox-to-create-portable-reproducible-python-environments/). It walks through requirements.txt and pyproject.toml projects (https://flox.dev/blog/using-flox-to-create-portable-reproducible-python-environments/). Use it when: a data or analytics team asks how Flox treats existing Python projects. The July 2025 Python post above is the shorter, newer take.
• 2024-03-13 Why we built Flox. Fact: “you would rm -rf an entire project and re- git clone it from source.” (https://flox.dev/blog/why-we-built-flox/). The author, Graham Hudgins, uses the habit to explain the cost of works-on-my-machine (https://flox.dev/blog/why-we-built-flox/). Use it when: you need the origin story and a relatable opener.
• 2023-05-16 Rust & Nix: Parallels in Complexity Management. Fact: “Microsoft has highlighted that 70% of CVEs are memory safety issues” that a borrow checker approach would prevent (https://flox.dev/blog/rust-nix-parallels-in-complexity-management/). The post argues Nix does for builds what Rust does for programs (https://flox.dev/blog/rust-nix-parallels-in-complexity-management/). Use it when: talking to Rust developers.
• 2022-10-28 Thank you NixCon!. Fact: “Last week, the Nix community got together in person for the first time in 3 years, in Paris,” (https://flox.dev/blog/thank-you-nixcon/). The post was written when Flox was still asking readers to sign up for the beta (https://flox.dev/blog/thank-you-nixcon/). Use it when: you need a date marker for how early the company was in 2022.