MIT Licensed · No Auth Token · 33+ AWS Services

Local AWS.
Zero cost.
Zero compromise.

Floci is a fast, free, open-source AWS emulator built with Quarkus Native. Starts in 24ms, uses 13 MiB at idle. Drop-in replacement for LocalStack — no auth token, no restrictions, ever.

Get Started → ★ Star on GitHub

24ms

Startup time

138× faster than LocalStack

13 MiB

Idle memory

91% less than LocalStack

289/s

Lambda throughput

2.4× faster than LocalStack

1,873/1,873

SDK compat tests

100% pass rate

—

GitHub stars

github.com/floci-io/floci

S3 · REST XML SQS · FIFO + Standard Lambda · Docker Native DynamoDB · Streams Cognito · JWKS ElastiCache · IAM Auth RDS · PostgreSQL + MySQL API Gateway v1 + v2 Step Functions · ASL CloudFormation · Stacks EventBridge · Rules KMS · Sign + Verify S3 · REST XML SQS · FIFO + Standard Lambda · Docker Native DynamoDB · Streams Cognito · JWKS ElastiCache · IAM Auth RDS · PostgreSQL + MySQL API Gateway v1 + v2 Step Functions · ASL CloudFormation · Stacks EventBridge · Rules KMS · Sign + Verify

Why Floci

Built for developers who ship.

No gatekeeping. No pricing tiers. No surprises. Just a reliable AWS environment that starts instantly and works everywhere.

🚀

No auth token. Ever.

Pull the Docker image and go. No sign-ups, no API keys, no telemetry. LocalStack required an auth token starting March 2026 — Floci never will.

⚡

138× faster startup

Native binary compiled with GraalVM Mandrel. Floci starts in 24ms vs ~3,300ms for LocalStack. Your CI pipeline will thank you.

💾

91% less memory

13 MiB idle footprint vs 143 MiB. Native binary, no JVM overhead, no bundled Python runtime. Fits comfortably on the smallest CI runners.

🔓

Truly MIT licensed

Fork it, embed it, extend it. No "community edition" sunset. No "enterprise" feature flags. Every service available to every developer, always.

☁️

33 AWS services

From S3 to Step Functions to RDS to Cognito. Services that LocalStack Community Edition doesn't even offer — ElastiCache, RDS, API Gateway v2 — are all here, free.

🔁

Drop-in replacement

Same port 4566. Same wire protocols. Same AWS SDK calls. Switch from LocalStack by changing zero lines of application code — just update your endpoint URL.

Benchmarks

Performance that actually matters.

Real numbers from a 1,873-test AWS SDK compatibility suite. Floci Native vs LocalStack Community 4.14.0.

Startup Time

Floci Native 24 ms 138× faster

LocalStack 3,300 ms

Idle Memory

Floci Native 13 MiB 91% less

LocalStack 143 MiB

Lambda Throughput (req/s)

Floci Native 289 req/s 2.4× faster

LocalStack 120 req/s

Lambda Warm Latency (avg)

Floci Native 2 ms 5× faster

LocalStack 10 ms

~90MB

Docker image
vs 1.0 GB LocalStack

100%

SDK tests pass
1,873 of 1,873 checks

AWS services
all free, all unlocked

Forever free
no auth token

Docker Image Size

Floci Native ~90 MB

LocalStack ~1.0 GB

SDK Compatibility (selected suites)

DynamoDB Streams

12/12 ✓

LS: 8/12

API Gateway v2

5/5 ✓

LS: 0/5

STS

18/18 ✓

LS: 6/18

Kinesis

15/15 ✓

LS: 8/15

Cognito

8/8 ✓

LS: 0/8

RDS

50/50 ✓

LS: N/A

True Parity

Real engines. Real protocols.

Floci doesn't just mock responses. For complex data services, it orchestrates real engines in Docker containers to guarantee 100% protocol fidelity.

Lambda Runtimes

Execution happens in isolated Docker containers using real AWS runtimes. Supports Node.js, Python, Java, Go, and more with identical environment variables and filesystem layout.

Isolated Execution

RDS Engines

Spin up real PostgreSQL or MySQL instances. Floci manages the lifecycle, handles snapshot/restore, and proxies JDBC traffic with full IAM database authentication support.

JDBC Wire Parity

ElastiCache (Redis)

A real Redis container is used for the data plane. Floci acts as a SigV4 proxy, allowing you to use real IAM roles to authenticate against your local Redis cluster.

RESP Protocol

Amazon ECS

Run containerized tasks locally. Floci orchestrates real Docker containers for your task definitions, providing a local control plane for task lifecycle management.

Container Fidelity

OpenSearch

Run real OpenSearch clusters. Floci manages the underlying engine nodes, providing a fully functional search backend that supports the complete OpenSearch API suite.

Search Fidelity

MSK (Kafka)

Orchestrate real Apache Kafka clusters. Perfect for testing event-driven architectures locally with the same streaming performance and semantics as Amazon MSK.

Streaming Parity

IAM Integration

Real IAM. Real security. Local.

Lambda, ElastiCache, and RDS all support full IAM authentication and SigV4 validation — just like production AWS.

Lambda

Function Execution with IAM

Functions run in real Docker containers with IAM role assumption and execution context. Full warm pool management, aliases, and event source mappings.

Docker-native execution (Node, Python, Java, Go, Ruby)
SQS, Kinesis, and DynamoDB Streams ESM triggers
Function URLs with IAM or public access control
Aliases, versions, concurrency controls
25 Lambda operations supported

ElastiCache

Redis with IAM Auth

Real Redis instance running in Docker, proxied through Floci with full IAM authentication via SigV4 token validation — identical to production.

Redis via Docker — real RESP protocol
IAM auth with SigV4 signature validation
Seamless cluster & replication group creation
Snapshot and restore support
21/21 SDK tests passing

RDS

Postgres & MySQL with IAM

PostgreSQL and MySQL databases running in Docker, with full IAM database authentication and JDBC wire protocol proxying. 50/50 SDK tests pass.

PostgreSQL and MySQL via Docker
IAM database authentication over JDBC
Snapshot, restore, parameter groups
Multi-AZ configuration support
50/50 SDK tests passing

Supported Services

33 AWS services. All of them free.

Every service is fully unlocked, no paid tier required. Services marked with ★ are exclusive to Floci — not available in LocalStack Community.

S3REST XML

SQSQuery / JSON

SNSQuery / JSON

DynamoDB + StreamsJSON 1.1

LambdaREST JSON

API Gateway RESTREST JSON

API Gateway v2 ★REST JSON

IAMQuery (65+ ops)

STSQuery (7 ops)

Cognito ★JSON 1.1

KMSJSON 1.1

KinesisJSON 1.1

Secrets ManagerJSON 1.1

SSM Parameter StoreJSON 1.1

CloudFormationQuery

Step FunctionsJSON 1.1

ElastiCache ★Redis + IAM

RDS ★PG + MySQL + IAM

EventBridge + SchedulerJSON 1.1

CloudWatch LogsJSON 1.1

CloudWatch MetricsQuery

MSK (Kafka)REST JSON

ECSJSON 1.1

EC2Query

ACMJSON 1.1

ECRJSON 1.1

SES + SES v2Query / JSON

OpenSearchREST JSON

AppConfigREST JSON

★ Services not available in LocalStack Community Edition

Comparison

Floci vs LocalStack Community

LocalStack required an auth token starting March 2026 and locked down their community edition. Floci fills that gap completely.

Feature	Floci	LocalStack Community
Price	Free forever	Auth token required
CI/CD usage	Unlimited	Auth token required / Limits
License	MIT	Restricted / proprietary
Startup time	~24 ms	~3,300 ms
Idle memory	~13 MiB	~143 MiB
Docker image size	~90 MB	~1.0 GB
API Gateway v2 / HTTP	✓ Full	✗ Not available
Cognito	✓ Full	✗ Not available
ElastiCache	✓ Docker + IAM	✗ Not available
RDS	✓ Docker + IAM	✗ Not available
STS (full)	✓ 7/7 ops	⚠ 3/7 ops missing
IAM coverage	✓ 65+ ops	⚠ Partial
DynamoDB Streams	✓ Full	⚠ Partial
S3 Event Notifications	✓ Full	✗ SNS subscription fails
SDK compatibility	100% (1,873/1,873)	Partial

Quick Start

Up and running in 30 seconds.

One Docker command. All 33 services on port 4566. No configuration required.

Docker

          # Pull and run — all services on :4566

          docker run --rm -p 4566:4566 \
  hectorvent/floci:latest
        

AWS CLI

          # Point CLI at Floci

          aws --endpoint-url http://localhost:4566 \
  s3 mb s3://my-bucket

          aws --endpoint-url http://localhost:4566 \
  sqs create-queue --queue-name my-queue

docker-compose (Lambda + ElastiCache + RDS)

          services:

            floci:

              image: hectorvent/floci:latest

              ports:

                - "4566:4566"

              volumes:

                - /var/run/docker.sock:/var/run/docker.sock

                - ./data:/app/data

              environment:

                FLOCI_STORAGE_MODE: hybrid

                FLOCI_SERVICES_DOCKER_NETWORK: myapp_default

Java SDK v2

          S3Client s3 = S3Client.builder()

            .endpointOverride(URI.create("http://localhost:4566"))

            .region(Region.US_EAST_1)

            .credentialsProvider(

              StaticCredentialsProvider.create(

                AwsBasicCredentials.create("test", "test")))

            .build();

Local AWS. Zero cost. Zero compromise.

Built for developers who ship.

No auth token. Ever.

138× faster startup

91% less memory

Truly MIT licensed

33 AWS services

Drop-in replacement

Performance that actually matters.

Real engines. Real protocols.

Real IAM. Real security. Local.

Function Execution with IAM

Redis with IAM Auth

Postgres & MySQL with IAM

33 AWS services. All of them free.

Floci vs LocalStack Community

Up and running in 30 seconds.

Docker

AWS CLI

docker-compose (Lambda + ElastiCache + RDS)

Java SDK v2

Light, fluffy, and always free.

Local AWS.
Zero cost.
Zero compromise.