Floci — Fast, Free AWS Emulator

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.

☁️

45 AWS services

From S3 to Step Functions to RDS to Textract. Services LocalStack Community doesn't offer — ElastiCache, RDS, API Gateway v2 + WebSocket, Route53, Auto Scaling, Textract — 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.

🔒

Optional TLS / HTTPS

Enable HTTPS with one env var — Floci auto-generates a self-signed certificate at startup. Test TLS-sensitive code paths locally without managing certificates manually.

🏢

Per-account isolation

Full multi-tenancy support: each AWS account ID gets its own isolated storage. Run multiple environments — dev, staging, test — on a single Floci instance without interference.

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, MySQL, or MariaDB 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 via Redpanda. Perfect for testing event-driven architectures locally with the same streaming performance and semantics as Amazon MSK.

Streaming Parity

ECR Registry

A real OCI-compatible registry (registry:2) backs every repository. Push and pull with the stock docker client — including image-backed Lambda functions resolved automatically.

OCI Wire Parity

⚙

CodeBuild

StartBuild launches real Docker containers using the configured build image. Build output streams live to CloudWatch Logs and artifacts are uploaded to S3 via docker cp — works in Docker-in-Docker CI pipelines.

Real Build Execution

Athena

Query execution runs inside a container sidecar backed by DuckDB. SQL queries against S3 data run in an isolated Docker container — same execution model as AWS Athena, no mocking.

Query Fidelity

⊞

EC2 Instances

RunInstances launches real Docker containers mapped to AMIs. SSH key injection, UserData execution, and IMDS (IMDSv1 + IMDSv2, port 9169) with IAM credential serving — identical environment to production EC2.

IMDS + SSH Fidelity

IAM Integration

Real IAM. Real security. Local.

Lambda, ElastiCache, RDS, ECS, EC2, MSK, EKS, OpenSearch, ECR, and CodeBuild 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, event source mappings, and Cognito Lambda triggers.

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

ElastiCache

Redis / Valkey 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 & MariaDB with IAM

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

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

Feature	Floci	LocalStack Community
Price	Free forever	Auth token required
License	MIT	Restricted / BSL
Security updates	✓ Active	✗ Frozen (March 2026)
Startup time	~24 ms	~3.3 s
Idle memory	~13 MiB	~143 MiB
Docker image size	~90 MB	~1.0 GB
ECS / EKS / EC2 / RDS / ElastiCache	✓ Real Docker engines	✗ Not available
SDK compatibility	100% (1,925/1,925)	Partial

Quick Start

Up and running in 30 seconds.

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

Docker

          # Pull and run — all services on :4566

          docker run --rm -p 4566:4566 \
  floci/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: floci/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();

Examples

Real workflows. Local environment.

End-to-end recipes for services that go beyond a simple API call — no cloud account needed.

        # Set up environment — no --endpoint-url needed after this

        export AWS_ENDPOINT_URL=http://localhost:4566

export AWS_DEFAULT_REGION=us-east-1

export AWS_ACCESS_KEY_ID=test

export AWS_SECRET_ACCESS_KEY=test

        # 1 — Start Floci (Docker socket required for real k3s clusters)

        docker run -d --name floci -p 4566:4566 \

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

  -u root floci/floci:latest

        # 2 — Create an EKS cluster (Floci spins up a real k3s node)

        aws eks create-cluster \

    --name dev-cluster \

    --role-arn arn:aws:iam::000000000000:role/eks-role \

    --resources-vpc-config subnetIds=subnet-00000001

        # 3 — Pull kubeconfig (Floci returns a live kubeconfig for the k3s API)

        aws eks update-kubeconfig --name dev-cluster

        # 4 — Deploy a workload — same kubectl commands as prod

        kubectl run nginx --image=nginx:alpine --port=80

kubectl expose pod nginx --type=NodePort --port=80

kubectl get pods,svc

        # 5 — Clean up

        aws eks delete-cluster --name dev-cluster

        # Set up environment — no --endpoint-url needed after this

        export AWS_ENDPOINT_URL=http://localhost:4566

export AWS_DEFAULT_REGION=us-east-1

export AWS_ACCESS_KEY_ID=test

export AWS_SECRET_ACCESS_KEY=test

        # 1 — Create a key pair and save it

        aws ec2 create-key-pair --key-name floci-key \

  --query 'KeyMaterial' --output text > floci-key.pem

chmod 600 floci-key.pem

        # 2 — Launch an EC2 instance (Floci starts a real Docker container)

        INSTANCE_ID=$(aws ec2 run-instances \

    --image-id ami-000000000001 \

    --instance-type t3.micro \

    --key-name floci-key \

    --user-data '#!/bin/sh\nyum install -y python3' \

  --query 'Instances[0].InstanceId' --output text)

        # 3 — Get the container's IP address

        IP=$(aws ec2 describe-instances --instance-ids $INSTANCE_ID \

  --query 'Reservations[0].Instances[0].PublicIpAddress' --output text)

        # 4 — Write the Ansible inventory

        cat > inventory.yml <<EOF

all:

  hosts:

    floci-ec2:

      ansible_host: $IP

      ansible_user: ec2-user

      ansible_ssh_private_key_file: ./floci-key.pem

      ansible_ssh_extra_args: '-o StrictHostKeyChecking=no'

EOF

        # 5 — Run the playbook

        ansible-playbook -i inventory.yml playbook.yml

        # playbook.yml

        - name: Configure Floci EC2

  hosts: all

  become: true

  tasks:

    - name: Install nginx

      package: { name: nginx, state: present }

    - name: Start nginx

      service: { name: nginx, state: started, enabled: true }

        # Set up environment — no --endpoint-url needed after this

        export AWS_ENDPOINT_URL=http://localhost:4566

export AWS_DEFAULT_REGION=us-east-1

export AWS_ACCESS_KEY_ID=test

export AWS_SECRET_ACCESS_KEY=test

        # 1 — Register a task definition

        aws ecs register-task-definition \

    --family web-task \

    --network-mode bridge \

    --container-definitions '[{

      "name":"web",

      "image":"nginx:alpine",

      "portMappings":[{"containerPort":80,"hostPort":8081}],

      "memory":128,"cpu":64

    }]'

        # 2 — Create a cluster

        aws ecs create-cluster --cluster-name dev-cluster

        # 3 — Run a standalone task (Floci launches a real Docker container)

        TASK_ARN=$(aws ecs run-task \

    --cluster dev-cluster \

    --task-definition web-task \

    --count 1 \

  --query 'tasks[0].taskArn' --output text)

        # 4 — Check task status

        aws ecs describe-tasks \

    --cluster dev-cluster \

    --tasks $TASK_ARN \

  --query 'tasks[0].{status:lastStatus,ip:containers[0].networkInterfaces[0].privateIpv4Address}'

        # 5 — Create a long-running service (Floci keeps the container running)

        aws ecs create-service \

    --cluster dev-cluster \

    --service-name web-service \

    --task-definition web-task \

    --desired-count 2

        # 6 — List running tasks in the service

        aws ecs list-tasks \

    --cluster dev-cluster \

    --service-name web-service

        # Set up environment — no --endpoint-url needed after this

        export AWS_ENDPOINT_URL=http://localhost:4566

export AWS_DEFAULT_REGION=us-east-1

export AWS_ACCESS_KEY_ID=test

export AWS_SECRET_ACCESS_KEY=test

        # 1 — Upload real data to S3

        aws s3 mb s3://analytics-bucket

# Write sample NDJSON — one order per line

cat > orders.json <<EOF

{"order_id":"1001","customer":"alice","amount":42.50,"status":"shipped"}

{"order_id":"1002","customer":"bob","amount":18.00,"status":"pending"}

{"order_id":"1003","customer":"alice","amount":95.00,"status":"shipped"}

{"order_id":"1004","customer":"carol","amount":7.25,"status":"cancelled"}

EOF

aws s3 cp orders.json s3://analytics-bucket/orders/orders.json

        # 2 — Register a Glue table pointing at the S3 prefix

        aws glue create-database --database-input '{"Name":"shop"}'

aws glue create-table \

    --database-name shop \

    --table-input '{

      "Name":"orders",

      "StorageDescriptor":{

        "Location":"s3://analytics-bucket/orders/",

        "InputFormat":"org.apache.hadoop.mapred.TextInputFormat",

        "SerdeInfo":{"SerializationLibrary":"org.openx.data.jsonserde.JsonSerDe"},

        "Columns":[

          {"Name":"order_id","Type":"string"},

          {"Name":"customer","Type":"string"},

          {"Name":"amount","Type":"double"},

          {"Name":"status","Type":"string"}

        ]

      }

    }'

        # 3 — Start a real SQL query (runs in the floci-duck DuckDB sidecar)

        QUERY_ID=$(aws athena start-query-execution \

    --query-string "SELECT customer, SUM(amount) AS total

                   FROM shop.orders

                   WHERE status = 'shipped'

                   GROUP BY customer

                   ORDER BY total DESC" \

    --result-configuration '{"OutputLocation":"s3://analytics-bucket/results/"}' \

  --query 'QueryExecutionId' --output text)

        # 4 — Wait for completion and fetch results

        aws athena get-query-execution \

    --query-execution-id $QUERY_ID \

  --query 'QueryExecution.Status.State'

# Once SUCCEEDED:

aws athena get-query-results \

    --query-execution-id $QUERY_ID \

  --query 'ResultSet.Rows[*].Data[*].VarCharValue'

        # Expected output — real SQL executed by DuckDB against your S3 file:

        alice  137.50

bob    18.00

Local AWS.
Zero cost.
Zero compromise.

Built for developers who ship.

No auth token. Ever.

138× faster startup

91% less memory

Truly MIT licensed

45 AWS services

Drop-in replacement

Optional TLS / HTTPS

Per-account isolation

Switching from LocalStack? Two-minute migration.

Performance that actually matters.

Real engines. Real protocols.

Real IAM. Real security. Local.

Function Execution with IAM

Redis / Valkey with IAM Auth

Postgres, MySQL & MariaDB with IAM

45 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

Real workflows. Local environment.

Light, fluffy, and always free.

Local AWS. Zero cost. Zero compromise.

Built for developers who ship.

No auth token. Ever.

138× faster startup

91% less memory

Truly MIT licensed

45 AWS services

Drop-in replacement

Optional TLS / HTTPS

Per-account isolation

Switching from LocalStack? Two-minute migration.

Performance that actually matters.

Real engines. Real protocols.

Real IAM. Real security. Local.

Function Execution with IAM

Redis / Valkey with IAM Auth

Postgres, MySQL & MariaDB with IAM

45 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

Real workflows. Local environment.

Light, fluffy, and always free.

Local AWS.
Zero cost.
Zero compromise.