Floci starts in 24ms and idles at 13 MiB of RAM.
That number gets attention, and it tends to obscure the real story. It isn't about one clever optimization. It's about four open-source projects that have been quietly perfecting their respective jobs for years, stacked on top of each other in a way that makes the whole thing possible.
Floci is a free, MIT-licensed AWS emulator. It speaks the AWS wire protocols on localhost:4566, emulates 45 services, and is verified by 1,925 SDK compatibility tests across Java, Python, Node.js, Go, and Rust. Here's the stack underneath it.
Netty, the async I/O substrate
Netty has been around since 2004. If you've used Elasticsearch, Cassandra, gRPC-Java, Pulsar, Spark, the AWS SDK v2 async client, or Spring WebFlux (via Reactor Netty), you've used Netty. Every TCP connection into Floci, every UDP datagram, every connection to a spawned RDS container terminates in a Netty channel pipeline somewhere.
Two decades of hardening by Apple, LinkedIn, Twitter, and basically every JVM-based hyperscaler. The bugs at the protocol-decoder level have been found and fixed. The performance characteristics are extremely well understood. And critically, Netty has been a good citizen of the native-image world. It plays well with GraalVM out of the box.
Vert.x, the reactive toolkit
Vert.x is the layer where Floci uses things directly. It's Netty with ergonomics: an event loop, a router, protocol-specific APIs for HTTP, DNS, TCP, WebSockets, gRPC, all sharing the same threading model.
Floci uses Vert.x for two things that matter.
The HTTP router. AWS routing is weird. The same TCP endpoint serves REST-XML (S3), REST-JSON, x-amz-json-1.0 and 1.1 (DynamoDB), query-string protocol (older services), and EC2 query protocol. Vert.x's router gives you full control over dispatch without forcing a single framework's idea of what a controller looks like.
The embedded DNS server. Floci runs its own authoritative DNS on UDP/53 inside the container, so *.localhost.floci.io resolves to Floci's container IP on the Docker network. That's how virtual-hosted S3 (https://my-bucket.s3.localhost.floci.io/key) works from inside spawned Lambda containers with no extra setup. Tractable in Vert.x because HTTP, UDP, and TCP all share infrastructure: same event loop, same lifecycle. About 200 lines.
Quarkus, the framework layer
This is where Floci becomes a coherent application instead of a pile of libraries.
Quarkus does at compile time what traditional frameworks do at runtime: bean discovery, dependency injection wiring, configuration resolution, JAX-RS route registration, Jackson serializer generation. That matters because GraalVM is a closed-world compiler. It has to know at compile time every class that might be loaded and every method that might be called via reflection. Quarkus is engineered from the ground up to give the native compiler that information.
The validating case for Quarkus is Keycloak, which migrated its entire codebase from WildFly to Quarkus in 2023, explicitly citing startup time and memory. When a project of that scale and conservatism makes that move, it's a strong signal.
GraalVM Mandrel, the native-image compiler
This is the layer that delivers the headline numbers. Ahead-of-time compilation. Closed-world analysis. Dead code elimination. The output is a single statically-linked native executable. No JVM at runtime, no JIT warmup, no classpath scanning at startup.
| Metric | Floci (native) | Typical JVM |
|---|---|---|
| Startup | ~24 ms | 2,000 to 6,000 ms |
| Idle RAM | ~13 MiB | 200 to 400 MiB |
Mandrel is Red Hat's downstream of GraalVM, tuned for Quarkus workloads, with release cadence aligned to Quarkus. An underrated piece of supply-chain hygiene.
Thank you
Floci wouldn't exist without any of these layers. Forty-five AWS services is a lot of surface area for one maintainer. The reason it's tractable is that the four layers below don't need maintenance. They're production-hardened by people I'll never meet, and I get to focus on AWS wire-protocol fidelity, which is the interesting part of an emulator.
Thank you to the Netty, Vert.x, Quarkus, and GraalVM teams. Floci stands on your shoulders.