---
title: "Fly Machines"
description: "23 posts about Fly Machines, summarised, each linking to the original."
---

# Fly Machines
> 23 posts about Fly Machines, summarised, each linking to the original.

## Articles

### [The Design & Implementation of Sprites](https://yomu.fyi/post/the-design-implementation-of-sprites.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jan 14, 2026
- Type: Explainer

Sprites are Linux virtual machines designed as fast, disposable computers with root access, persistent 100GB durable filesystems, automatic sleeping, and low inactive cost. To make creation feel instantaneous, the platform removes user-facing OCI container images and keeps pools of preloaded standard Fly Machines, so a new Sprite mainly performs startup work rather than pulling and unpacking an image. Its storage stack follows a hacked-up JuiceFS model, splitting immutable data chunks from metadata, keeping metadata durable with Litestream, and using a sparse NVMe volume as a dm-cache-like read-through cache for object storage; checkpoints and restores primarily shuffle metadata. This design supports migration and recovery without depending on local storage, while low-cost sleeping and object-backed disks suit interactive work more than warm, containerized production workloads, and billing applies only to storage blocks actually written.


### [Games as Model Eval: 1-Click Deploy AI Town on Fly.io](https://yomu.fyi/post/games-as-model-eval-1-click-deploy-ai-town-on-fly-io.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Aug 11, 2025
- Type: Announcement

Daniel Botha argues that conventional benchmarks reveal little about how models behave in long-context, interactive situations or whether they deliver the tone a product requires. He presents games as a more observable evaluation setting, because success signals are unambiguous and gameplay exposes strategic reasoning, long-term planning, and adaptation with opponents or collaborators. The post focuses on a fork of a16z-infra’s AI Town, a pixel-art simulation inspired by Generative Agents: Interactive Simulacra of Human Behavior, where characters remember conversations, maintain relationships, react to events, and stay in character. A single deploy script runs the project on Fly Machines with scale to zero, cost and performance optimizations, and support for OpenAI-compatible services, Together.ai models, and custom embedding models configured through secrets.


### [Phoenix.new – The Remote AI Runtime for Phoenix](https://yomu.fyi/post/phoenix-new-the-remote-ai-runtime-for-phoenix.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jun 20, 2025
- Type: Announcement

Phoenix.new is presented as a batteries-included, fully online coding agent designed for Elixir and Phoenix, after an initial weekend project grew into a system that generated Phoenix applications and drove an in-browser IDE. It runs in an ephemeral Fly Machine, giving the agent and user a shared root shell while isolating local machines; applications launch in the cloud with preview URLs, GitHub integration, and Fly.io infrastructure guardrails. A headless Chrome browser lets the agent inspect page content and JavaScript state, interact with front ends, and correlate changes with server-side logs while testing applications. The system already handles full-stack applications using WebSockets, Phoenix Presence, and real databases, can work with other installed languages and frameworks, and is being used to triage GitHub issues and produce pull requests asynchronously.


### [Our Best Customers Are Now Robots](https://yomu.fyi/post/our-best-customers-are-now-robots.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Apr 8, 2025
- Type: Explainer

Fly.io reports that users driving the platform’s most recent growth are robots rather than people, prompting a reconsideration of developer experience (DX) as the primary product lens. The post describes how vibe-coding workflows use Fly Machines—Docker containers running as hardware-isolated virtual machines—to create, modify, stop, and rapidly restart environments without paying during stopped periods. These workflows favor incremental filesystem state, object storage, and controllable routing for MCP connections, including potentially long-lived SSE connections that should reach the same stateful instance. Fly.io also proposes exposing its API through MCP and using sealed, tokenized secrets so isolated machines can substitute real OAuth credentials only when needed. It concludes that a useful robot experience (RX) will require more than an MCP interface, while managed Postgres remains the company’s most important engineering priority and the platform is still primarily designed for humans.


### [The Exit Interview: JP Phillips](https://yomu.fyi/post/the-exit-interview-jp-phillips.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 12, 2025
- Type: Announcement

JP Phillips leaves after four years at Fly.io, saying the company’s increasing focus on Managed Postgres and LLMs does not match the direction he hoped to see: a move toward cloud provision and larger established customers. He says his original goal—building Fly Machines to replace HashiCorp Nomad—has been accomplished, with the platform now capable of supporting the next iteration of products. His central engineering contribution was the Fly Machines API and flyd, an independently running orchestrator whose finite-state-machine invocations use deterministic, durable execution and log each step in BoltDB. He also discusses corrosion2, a Rust service that uses SWIM gossip and a CRDT-structured SQLite database to distribute near-real-time machine state. Phillips criticizes GraphQL, Elixir, inconsistent communication and shifting priorities, while defending BoltDB and praising Rust’s productivity.


### [AI GPU Clusters, From Your Laptop, With Livebook](https://yomu.fyi/post/ai-gpu-clusters-from-your-laptop-with-livebook.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Sep 24, 2024
- Type: Explainer

Livebook, FLAME, and the Nx stack combine Elixir notebooks, elastic execution, and GPU-backed machine learning into a workflow that can move from a laptop to remote infrastructure. Livebook can start runtimes on Fly Machines, connect to existing Erlang/Elixir applications, and synchronize notebook dependencies and modules across nodes while preserving access to private resources within a Fly organization. FLAME wraps arbitrary code in Flame.call, manages executor pools, controls node limits and concurrency, streams results, and shuts down idle nodes or the cluster after disconnection. In the demonstrated AI workflow, video stills are processed on GPU Fly Machines with Llama, then Mistral summarizes the returned descriptions. The same setup also drives a 64-GPU hyperparameter run for BERT, with each L40s node preparing dependencies, loading data, fine-tuning, and streaming chart results to Livebook.


### [Making Machines Move](https://yomu.fyi/post/making-machines-move.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jul 30, 2024
- Type: Problem & solution

Fly.io needed to restore the ability to drain physical workers after attached NVMe volumes made stateful Fly Machines tied to particular servers. Snapshot restoration could lose data, while killing a machine before copying its volume caused unacceptable downtime; copying first risked losing writes. The solution was an asynchronous clone operation built around Linux device mapper’s dm-clone: a new volume is created immediately, reads of unhydrated blocks are fetched from the original over iSCSI, writes go to the destination, and background copying rehydrates the rest. The work also required orchestration across flyd and a fix for Fly Postgres configurations containing literal 6PN IPv6 addresses. After cautious early migrations, the infrastructure team could drain hosts without much ceremony by summer 2024, though routine automated rebalancing remained a future goal.


### [AWS without Access Keys](https://yomu.fyi/post/aws-without-access-keys.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jun 19, 2024
- Type: Problem & solution

The post describes how Fly Machines can access AWS resources such as an S3 bucket without distributing long-lived AWS access keys. It uses OpenID Connect (OIDC): AWS IAM trusts Fly.io’s OIDC identity provider, a role grants narrowly scoped permissions, and the app receives the role ARN as an environment variable. At boot, Fly’s Rust init requests a machine-specific OIDC token through the /.fly/api Unix socket, writes it to /.fly/oidc\_token, and sets AWS\_WEB\_IDENTITY\_TOKEN\_FILE and AWS\_ROLE\_SESSION\_NAME so the AWS SDK can call STS AssumeRoleWithWebIdentity. AWS verifies the token, issues short-lived credentials, and evaluates the role’s IAM policy before serving the requested object. The trust policy can constrain tokens by audience and subject, including an organization, Fly App, or machine; the same pattern can authenticate against other OIDC-compliant providers, although Azure and GCP lack equivalent init integration.


### [Fly Kubernetes does more now](https://yomu.fyi/post/fly-kubernetes-does-more-now.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Mar 7, 2024
- Type: Announcement

Fly Kubernetes is moving from early access to a closed beta as a managed Kubernetes service backed by Fly.io infrastructure. It provides the Kubernetes API while mapping core primitives to Fly resources: containers become Firecracker microVMs through flyd and Firecracker, pods become Fly Machines, networking uses an internal WireGuard mesh, services use the Fly Proxy, and storage uses Fly Volumes. Virtual Kubelet, running alongside K3s, receives pod requests and deploys them through the Fly Machines API, removing user-managed node capacity planning and hardware management. The beta supports workloads, including GPUs, across available regions, with Deployments/ReplicaSets, Services, DNS, and ephemeral and persistent volumes, but only part of the Kubernetes API. Missing capabilities include multi-container pods, StatefulSets, network policies, horizontal pod autoscaling, and emptyDir volumes; pricing is free during beta and planned at $75 per cluster monthly afterward, excluding resource costs.


### [Event Driven Machines](https://yomu.fyi/post/event-driven-machines.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 5, 2024
- Type: Problem & solution

Event Driven Machines presents Lambdo, a pattern for using Fly Machines as short-lived, event-triggered compute rather than relying on HTTP activation. It polls an SQS queue for JSON events, batches the messages and metadata, then creates fast-booting Fly Machines with the events written to /tmp/events.json; the Machine is destroyed after processing finishes. Application code can come from an existing codebase or Lambdo’s Node and PHP runtime images, with handlers or commands processing each event. SQS message attributes select the required image and can specify VM size and command, while the approach supports arbitrary code and even GPU-enabled Machines, giving each event control over its execution environment.


### [Delegating tasks to Fly Machines](https://yomu.fyi/post/delegating-tasks-to-fly-machines.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 1, 2024
- Type: Tutorial

Resource-intensive web tasks such as resizing high-resolution images can require substantially more memory or CPU than ordinary request handling, making an always-powerful web server inefficient. The article presents a framework- and language-agnostic delegation pattern using Fly Machines, the private network, and two process groups that run the same application with different Machine specifications. A Next.js route calls a wrapper that executes the task when FLY\_PROCESS\_GROUP is worker; otherwise, it sends a POST request to the identical endpoint through the worker’s internal hostname, returning the worker’s response. The example uses a lighter web group and a performance-4x worker group, with local development using separate ports and production routing over .internal addresses; the author calls the implementation naïve and suggests queues and worker timeouts to improve resilience and control worker availability.


### [Print on Demand](https://yomu.fyi/post/print-on-demand.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Nov 29, 2023
- Type: Problem & solution

Print on Demand presents a resource-conscious alternative to scaling an application by separating PDF generation from the main server. The post explains how a Fly.io PDF appliance uses Fly-Replay to route a PDF request to a machine running headless Chrome, which requests the original page without its “.pdf” extension and converts the returned HTML into a PDF. Each machine reuses one Chrome instance across requests, while auto\_stop\_machines allows idle machines to stop and restart on demand. Integration requires cloning the GitHub repository, creating and configuring an app, deploying it, and returning a fly-replay response header for PDF-directed requests. The extracted production code is packaged for deployment with existing applications, supports session, cookies, and basic authentication through passed-back HTTP headers, and can serve applications using different languages and frameworks.


### [We Raised A Bunch Of Money](https://yomu.fyi/post/we-raised-a-bunch-of-money.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jun 27, 2023
- Type: Announcement

Fly.io announces $25MM from A16Z and existing investors followed by $70MM led by EQT Ventures, and uses the occasion to explain its platform vision. Its central problem is the “two hour” barrier: ordinary tooling makes global deployment, VMs, real-time features, encryption, and clustered databases too difficult to pursue quickly, leaving many applications concentrated in us-east-1. The company’s approach is to build a hardware-backed platform and toolchain spanning many regions, with Fly Machines making on-demand VM creation as straightforward as a function call. Funding will support 33 regions, support and reliability, advanced storage, security capabilities, and new hardware while preserving a self-service experience for containerized applications. The stated user-facing promise is that an existing Docker container can run on Fly.io in single-digit minutes and reach every continent in another minute or two.


### [Python Async Workers on Fly Machines](https://yomu.fyi/post/python-async-workers-on-fly-machines.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: May 31, 2023
- Type: Tutorial

A Python web app needed to build and install libraries without blocking HTTP requests or risking backend failures when resource-heavy builds overlapped. The initial backend implementation sometimes ran for more than 30 minutes and could kill the backend, while always-on Celery workers left capacity idle. The proposed proof of concept stores job parameters in Redis, starts a Fly Machine through the Machines API with Redis key environment variables, executes a Python function, and writes the result back. A status endpoint polls the Machine state and returns PENDING until completion, after which cleanup deletes the Machine and Redis entries. The design pays for worker resources only during jobs, but the example requires JSON-serializable arguments and results and is presented as a simple implementation rather than a full job system.


### [Carving The Scheduler Out Of Our Orchestrator](https://yomu.fyi/post/carving-the-scheduler-out-of-our-orchestrator.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Feb 1, 2023
- Type: Explainer

Fly.io describes why it is carving scheduling out of its existing Nomad-based orchestrator and replacing it with a simpler system centered on flyd and AppsV2. It first reduces orchestration to a client-server supervisor, then explains centralized scheduling: workers register resources, while a server filters candidates by constraints and ranks them. The proposed design avoids jobs sitting pending or being placed in nearby but incorrect regions; requesting VMs in MAD yields MAD capacity or nothing. Policy-heavy behavior such as deployment spares, crash recovery across workers, and regional decisions moves into flyctl and other platform components rather than the scheduler. Fly Machines already exposes APIs to reserve, start, and stop individual VMs, with Nomad still used in January 2023 and flyd expected for deployments in December 2023.


### [Real-Time Collaboration with Replicache and Fly-Replay](https://yomu.fyi/post/real-time-collaboration-with-replicache-and-fly-replay.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Nov 23, 2022
- Type: Problem & solution

Distributed real-time collaboration becomes difficult when a single server coordinating document changes is overloaded and documents must be split across machines without exposing routing complexity to clients. This demo combines Replicache, a custom WebSocket endpoint, Fly Machines, and the Fly-Replay header to route each document’s connection through a shared router to the machine responsible for that document. The server keeps connections by spaceID, sends initial and incremental state, and tracks messages already delivered; the client overrides Replicache’s push and pull handlers to exchange data through the persistent socket. The resulting application has React frontend, Express router, and Replicache/WebSocket backend layers, with each todo list assigned to one backend machine. The author cautions that the approach is demonstrated only in a basic demo and should receive serious production testing and tuning.


### [Logbook: October 29 to November 6, 2022](https://yomu.fyi/post/logbook-october-29-to-november-6-2022.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Nov 8, 2022
- Type: Announcement

This weekly logbook covering October 29 through November 6, 2022 reports updates across Elixir, Postgres, Laravel Livewire, Redis, and Fly Machines. Chris McCord describes how React inspired Elixir LiveView, while revamped Elixir documentation and Livewire tutorials cover client-side pagination, grouping, sorting, and browser notifications from the server. Fly’s revised Postgres documentation distinguishes the tools it provides for provisioning and managing a cluster from the responsibilities customers retain, and points readers to managed Postgres services. The Fly Redis dashboard command opens the Upstash Redis console with instance statistics and connection instructions, while a Fly Machines preview supports defining multiple processes to run inside one container; the log also notes updated documentation and a required CLI version update.


### [Scale-to-Zero Minecraft server with Terraform and Fly Machines](https://yomu.fyi/post/scale-to-zero-minecraft-server-with-terraform-and-fly-machines.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Sep 14, 2022
- Type: Tutorial

This tutorial presents a scale-to-zero Minecraft Java server built with Terraform and Fly Machines. It addresses the cost and resource burden of keeping a multiplayer server running when nobody is playing, while allowing it to restart when a player connects. The configuration provisions a Fly.io app, a Firecracker-based machine using Geoff Bourne’s itzg/minecraft-server Docker image, a 15GB persistent Fly Volume, an IPv4 address, and exposed TCP port 25565. Environment variables enable Autostop with estimated and initial timeouts of 120 seconds, while the machine receives four shared vCPUs and 8GB of RAM and mounts world data at /data. After terraform apply, the machine shuts down after the timeout and automatically starts again when Minecraft reconnects, though any TCP traffic can wake it and incur costs.


### [Building an In-Browser IDE the Hard Way](https://yomu.fyi/post/building-an-in-browser-ide-the-hard-way.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Aug 15, 2022
- Type: Tutorial

This tutorial builds a personal remote development environment: an in-browser IDE for Elixir/Phoenix work, deployed as a Fly Machine from a Dockerfile and managed with command-line tools. The image uses an official Elixir base, adds code-server, flyctl, build dependencies, and the Elixir Language Server extension, while a multi-stage build copies in Tired Proxy. A persistent volume holds working files, and the startup configuration can clone a repository, launch code-server behind HTTPS, and arrange for the machine to sleep after an hour without HTTP requests. From the IDE terminal, the walkthrough then creates and deploys a separate Phoenix hello-world application backed by SQLite, setting its secret and provisioning storage. The resulting setup can wake on browser access, but random HTTP traffic or an active code-server terminal may keep it running, and stopping or destroying the apps limits costs.


### [Logbook - 2022-07-18](https://yomu.fyi/post/logbook-2022-07-18.md)
- Company: [Fly.io](https://yomu.fyi/company/fly-io.md)
- Published: Jul 18, 2022
- Type: Announcement

This Logbook entry records Fly.io product, platform, documentation, and interface changes on 2022-07-18. Highlights include $99 in usage credits for the Pro Plan, SOC2 compliance, persistent-volume expansion through fly volumes extend, SFTP access to apps over 6PN and WireGuard, and routing changes intended to improve latency. flyctl gained debug JSON formatting, expanded machine-app deployment and status commands, preserved mounted volumes during deployments, and added rolling deploys that wait for each VM to start. The entry also describes fixes for autoscaling, the Fly Redis image, GraphQL validation, Phoenix launches, and dashboard presentation, alongside updated Laravel and persistent-volume documentation and improved Heroku token-failure emails.


[Older posts](https://yomu.fyi/topic/fly-machines/page/2.md)