--- title: Two Free LocalStack Alternatives in 2026: MiniStack vs floci description: LocalStack went paid. MiniStack and floci both stepped up as free, MIT-licensed AWS emulators. We reviewed both — their architecture, services, and performance — so you can pick the right one for your team. url: https://www.factualminds.com/blog/ministack-free-localstack-alternative-aws-emulator/ datePublished: 2026-04-10T00:00:00.000Z dateModified: 2026-04-16T00:00:00.000Z author: Palaniappan P category: DevOps & CI/CD tags: localstack, ministack, floci, aws-emulator, developer-tools, local-development, devops --- # Two Free LocalStack Alternatives in 2026: MiniStack vs floci > LocalStack went paid. MiniStack and floci both stepped up as free, MIT-licensed AWS emulators. We reviewed both — their architecture, services, and performance — so you can pick the right one for your team. When LocalStack moved its core services behind a paid tier, the AWS developer community lost its go-to free emulator. Developers who relied on local S3, RDS, and Lambda testing suddenly faced a choice: pay up, build their own mock, or find an alternative. Two serious contenders have emerged: **MiniStack** and **floci**—both free, both MIT-licensed, both shipping within weeks of LocalStack's March 2026 community edition sunset. We reviewed both emulators—their architecture, services, performance, and real-world tradeoffs. By the end, you'll know which fits your team. ## What is MiniStack? MiniStack is a free, MIT-licensed AWS emulator that runs 38+ AWS services locally on a single port (4566). Unlike LocalStack, it requires no account, API key, or telemetry. Launch it once via Docker or pip, and you get a fully functional local AWS environment. **Key facts:** - **Language:** Python 3.12+ - **Install:** Docker, PyPI, or docker-compose - **License:** MIT (completely free, no commercial restrictions) - **Launch date:** April 7, 2026 (Product Hunt debut) - **Community:** 1,800+ GitHub stars, 900+ passing tests, actively maintained with multiple daily commits - **Services:** 38+ AWS services across compute, storage, databases, messaging, security, and more The project exists because LocalStack's free tier no longer exists. Nahuel Nucera and Johannes Grumböck built MiniStack as a direct answer to that gap—and it has earned the community's attention fast. ## The "Real Infrastructure" Difference Here is the architectural difference that sets MiniStack apart: **most AWS emulators mock the services. MiniStack spins up real containers.** When you request RDS in MiniStack, it does not pretend to be a PostgreSQL database—it launches a real PostgreSQL container and runs your SQL against it. Same for Redis (ElastiCache), Docker (ECS), and SQL queries (Athena via DuckDB). This "real infrastructure" approach has a direct benefit: **your local tests are more faithful to production.** Compare this to traditional mocks: - **Mocks** catch schema errors and API signature mistakes but miss database-specific behavior, transaction edge cases, and performance surprises. - **Real infrastructure** forces you to confront the same constraints your production code faces—connection pooling, query planning, concurrency limits. For teams with database-heavy applications, this is the difference between "tests passed locally but failed in production" and "tests are telling us the truth." ## 38+ AWS Services at a Glance Here is what MiniStack supports: | Category | Services | | ------------------ | -------------------------------------------------- | | **Storage** | S3, EBS, EFS, S3 Object Lock | | **Compute** | Lambda, EC2, ECS, EMR | | **Databases** | RDS (PostgreSQL/MySQL), DynamoDB, DynamoDB Streams | | **Caching** | ElastiCache (Redis) | | **Messaging** | SQS (FIFO + DLQ), SNS, Kinesis, EventBridge | | **Workflows** | Step Functions (full ASL interpreter) | | **APIs** | API Gateway v1/v2, AppSync | | **Analytics** | Athena (DuckDB-backed), Glue, Firehose | | **Security** | IAM, KMS, ACM, WAF v2, Secrets Manager, STS | | **Networking** | Route53, CloudFront, ALB/ELBv2 | | **Identity** | Cognito | | **Infrastructure** | CloudFormation, CloudWatch Logs/Metrics, SSM | | **Email** | SES, SESv2 | Lambda support deserves special mention: MiniStack maintains warm worker pools for Python and Node.js, and uses Docker Runtime Interface (RIE) emulation for Go and Rust binaries. This means your Lambda tests execute real code, not stubs. ## Quick Start **Installation:** Three paths. ```bash # Via pip pip install ministack && ministack # Via Docker docker run -p 4566:4566 nahuelnucera/ministack # Via docker-compose git clone https://github.com/Nahuel990/ministack.git cd ministack docker compose up -d ``` **Verify:** Check the health endpoint. ```bash curl http://localhost:4566/_ministack/health ``` **Use:** Point your AWS SDK to the local endpoint. Example with AWS CLI: ```bash aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket aws --endpoint-url=http://localhost:4566 s3 ls ``` With Terraform: ```hcl provider "aws" { region = "us-east-1" access_key = "test" secret_key = "test" endpoints { s3 = "http://localhost:4566" rds = "http://localhost:4566" } } ``` With Python boto3: ```python import boto3 s3 = boto3.client( 's3', endpoint_url='http://localhost:4566', aws_access_key_id='test', aws_secret_access_key='test', ) s3.create_bucket(Bucket='my-bucket') ``` The endpoint swap is the only required change. All existing code paths work unchanged. ## Performance Comparison Here is how both free alternatives stack up against LocalStack and each other: | Metric | LocalStack Free | LocalStack Pro | MiniStack | floci | | ------------------------------------ | ---------------------- | -------------- | -------------- | ------------------ | | **Price** | Now paid | $35+/month | Free forever | Free forever | | **License** | BSL | Proprietary | MIT | MIT | | **Startup time** | 15–30s | 15–30s | ~2s | **~24ms** | | **Memory (idle)** | ~500MB | ~500MB | ~30MB | **~13 MiB** | | **Image size** | ~1GB | ~1GB | ~250MB | **~90MB** | | **Auth required** | Yes (since March 2026) | Yes | No | No | | **RDS/ElastiCache/ECS** | Paid only | Included | Included, free | Included, free | | **EC2, EMR, EBS, EFS** | Paid only | Included | Included, free | Included, free | | **Core services** (S3, Lambda, etc.) | Paid | Included | Included | Included | | **Test coverage** | — | — | 900+ tests | **1,850+ tests** | | **Runtime** | Python/JVM | Python/JVM | Python | Go (native binary) | **The headline:** Both free alternatives boot faster, use less RAM, and include paid-only services at zero cost. floci's 24ms startup and 13 MiB footprint are exceptional for parallel CI; MiniStack's 2-second boot and real Postgres/Redis containers serve database-heavy test suites. Both are actively maintained with strong test coverage. ## Real-World Use Cases **Local development loops.** Developers run MiniStack once (`docker run`) and test S3 uploads, Lambda invocations, and DynamoDB queries without touching AWS. Zero cloud costs, instant feedback. **CI/CD integration.** MiniStack's 2-second startup makes it ideal for test pipelines. Spin up before tests, reset state, tear down after. With `POST /_ministack/reset`, you can nuke all state between test runs without restarting the container. **Terraform and CDK testing.** Write infrastructure as code, validate it locally against MiniStack before applying to staging or prod. Works with all major IaC frameworks (Terraform, AWS CDK, Pulumi, CloudFormation). **Integration testing with real databases.** Because MiniStack runs actual Postgres and Redis, you can test connection pooling, transaction isolation, and caching behavior that mocks would hide. **Multi-tenant isolation testing.** MiniStack's IAM support allows you to test cross-account access patterns locally. Create separate Access Key IDs to simulate tenant isolation. ## Limitations and Things to Watch MiniStack is impressive, but it has gaps. **Scope.** With 38 services, MiniStack covers the "80% of use cases" well. But if your code relies on niche services (e.g., AWS Timestream, AWS IoT Core, AWS Glue Catalog subtleties), you may hit unimplemented features. **Small team.** MiniStack is maintained by two developers. As AWS itself evolves (new services, feature launches, API changes), the maintenance burden grows. GitHub issue #221 flags "CODE FREEZE DUE MIGRATION," suggesting the team is mid-architecture refactor. Monitor the project's activity rate. **Early stage.** With 900+ tests and solid core coverage, MiniStack is stable for local dev and CI. But it has not yet reached the maturity of LocalStack Pro's multi-year refinement. Edge cases and lesser-used service parameters may differ from real AWS behavior. **No paid support tier.** If something breaks, you are relying on community issues and the maintainers' goodwill. For mission-critical CI, LocalStack Pro's commercial support may be worth the cost. ## Should You Switch? **Yes, if you:** - Are frustrated by LocalStack's paywall and need RDS, ElastiCache, or ECS locally - Want faster test cycles (2-second startup vs. 30 seconds saves real time in CI) - Are testing database-heavy applications and want real Postgres/MySQL, not mocks - Have simple, common AWS service use cases (S3, Lambda, DynamoDB, SQS, etc.) - Are using Terraform, CDK, or Pulumi and need a free validation environment **No, if you:** - Are already paying for LocalStack Pro and have a stable CI pipeline—switching has opportunity cost - Rely heavily on AWS service features that MiniStack does not yet implement - Need commercial support contracts for your local AWS emulation (niche, but important for some organizations) - Are testing very new or niche AWS services that MiniStack has not added yet **For most teams:** The free tier + real infrastructure makes MiniStack worth trying. If it covers your services, the performance and cost gains are real. --- ## Meet the Other Contender: floci MiniStack is not alone in the post-LocalStack landscape. **floci** emerged from the same frustration: LocalStack's March 2026 community edition sunset forced developers to choose between paying or finding an alternative. But floci took a different engineering path. Where MiniStack opts for real infrastructure containers (Postgres, Redis) with ~2-second startup, floci separates stateless services into lightweight in-process handlers and reserves real containers for database/cache services. The result: **24-millisecond startup, 13 MiB RAM at idle, and 1,850+ automated compatibility tests** across Java, Python, Node.js, Go, Rust, AWS CLI, Terraform, OpenTofu, and AWS CDK. If raw speed and small footprint are your priority, floci is worth exploring. ## What is floci? floci is a free, MIT-licensed AWS emulator written in Go. It runs on port 4566 (same as LocalStack) and requires zero account, API key, or telemetry. **Key facts:** - **Language:** Go (native binary) - **Install:** Docker Compose (`docker compose up`) or Docker image - **License:** MIT (completely free, no commercial restrictions) - **Launch:** March 2026 (same window as LocalStack's community edition sunset) - **Community:** 3,100+ GitHub stars, actively maintained - **Tests:** 1,850+ automated compatibility tests across 6 SDK languages and 3 IaC tools - **Maturity:** Early-stage but production-engineered; the test matrix signals serious intent ## Architecture: Stateless In-Process, Stateful Real Containers floci's speed comes from a clever architectural split: **In-process stateless services** (SSM, SQS, SNS, IAM, STS, KMS, Secrets Manager, SES, Cognito, Kinesis, OpenSearch, EventBridge, Step Functions, CloudFormation, ACM, API Gateway v1/v2, AppConfig, CloudWatch Logs/Metrics) run as lightweight handlers inside the floci binary. No Docker overhead. **In-process stateful services** (S3 with versioning and Object Lock, DynamoDB with streams and transactions) use in-memory or persistent state, still zero Docker startup cost. **Real container services** (Lambda, ElastiCache—Redis/Valkey with IAM auth, RDS—PostgreSQL/MySQL, ECS, EC2 with VPCs) spin up actual Docker containers when needed—same production fidelity as MiniStack, but only when you request them. This split explains the 24ms startup: you get the port open and request routing immediately; stateful services boot on-demand. Compare this to MiniStack, which always spins up Postgres and Redis containers (hence ~2 seconds), or LocalStack, which runs a full JVM and legacy Python codebase (15–30 seconds). ## Quick Start ```yaml services: floci: image: hectorvent/floci:latest ports: - '4566:4566' ``` Save this as `docker-compose.yml`, then: ```bash docker compose up ``` Point your AWS SDK to `http://localhost:4566` with dummy credentials (no real AWS account needed): ```bash aws --endpoint-url=http://localhost:4566 s3 mb s3://my-bucket ``` With Terraform: ```hcl provider "aws" { region = "us-east-1" access_key = "test" secret_key = "test" endpoints { s3 = "http://localhost:4566" rds = "http://localhost:4566" dynamodb = "http://localhost:4566" } } ``` With Python: ```python import boto3 s3 = boto3.client( 's3', endpoint_url='http://localhost:4566', aws_access_key_id='test', aws_secret_access_key='test', ) s3.create_bucket(Bucket='my-bucket') ``` The endpoint swap is the only required change. ## Storage and State Management floci supports multiple storage modes—memory, persistent, hybrid, and WAL—configurable per-service via `FLOCI_*` environment variables. This is useful if you need state to persist across container restarts (e.g., DynamoDB data surviving a redeploy during test runs). Example with persistent S3: ```yaml services: floci: image: hectorvent/floci:latest ports: - '4566:4566' environment: FLOCI_S3_STORAGE: persistent FLOCI_DYNAMODB_STORAGE: memory ``` ## MiniStack vs floci: Which One Is Right for You? Both are free, both are MIT-licensed, both work with all major AWS SDKs and IaC tools. The decision comes down to your priorities. **Choose floci if you:** - **Need the fastest startup.** 24ms vs. 2 seconds is meaningful in highly parallel CI pipelines (e.g., running 100 test containers concurrently). Every millisecond counts. - **Are in a resource-constrained environment.** 13 MiB idle RAM vs. 30 MB is significant for ephemeral test containers or local development on laptops with limited memory. - **Want production-grade compatibility assurance.** 1,850+ automated tests across Java, Node.js, Python, Go, Rust, AWS CLI, Terraform, OpenTofu, and AWS CDK signal serious engineering intent. MiniStack has 900+ tests; floci's broader test matrix covers more SDK variants. - **Need S3 Object Lock with COMPLIANCE and GOVERNANCE modes.** floci ships with full Object Lock support; MiniStack has it, but it's worth verifying for your use case. - **Are using Go, Rust, or polyglot teams.** floci's native binary is a good signal of Go/Rust support fidelity. **Choose MiniStack if you:** - **Want the widest service breadth.** Both support 38–40+ services, but service mix differs. MiniStack includes AppSync, Athena (DuckDB-backed), and Glue; verify your specific needs. - **Prefer pip install over Docker Compose.** `pip install ministack && ministack` is faster to trial than Docker setup if you're already in a Python environment. - **Are already running Python tooling.** If your test infrastructure is Python-centric, MiniStack's closer integration may reduce friction. - **Want real Postgres/MySQL/Redis always available without on-demand startup.** MiniStack's "always-on" containers simplify testing of connection pooling and persistence behavior. **When in doubt:** Try floci first. Its 24ms startup and 13 MiB footprint mean there's almost no cost to spin it up locally and see if it covers your service requirements. If it does, you've found the faster tool. If it doesn't, MiniStack is the next logical step. ## The Bigger Picture LocalStack's decision to commercialize created a vacuum, and two serious projects have filled it. **MiniStack** and **floci** represent different engineering philosophies: - **MiniStack:** Real infrastructure everywhere. Postgres, Redis, and Docker containers boot with every launch. Slower startup (~2s), higher memory, but true production fidelity. - **floci:** Stateless in-process, stateful containers on-demand. Lightning-fast startup (~24ms), tiny footprint, native binary. Production-engineered with 1,850+ compatibility tests. This competition is _good for developers_. LocalStack had no serious challenger, so its paywall stood unchallenged. Now, two free, MIT-licensed alternatives force real tradeoff discussions: Do you prioritize startup speed or breadth of services? Database-heavy code or lightweight CI? These decisions matter, and having genuine options makes them clear. Both projects ship with strong test coverage and active maintenance. MiniStack has 1,800+ GitHub stars; floci has 3,100+. Neither is a weekend side project. **Our recommendation:** - **For CI/CD pipelines:** Start with **floci**. Its 24ms startup is exceptional for parallel test runs. The 1,850+ compatibility tests signal production-grade engineering. - **For local development with database-heavy code:** Use **MiniStack**. The always-on Postgres and Redis containers mean you're testing real transaction isolation, connection pooling, and concurrency behavior from day one. - **If you hit a wall with either:** Try the other. The setup cost is low (30 minutes max), and the decision tree we've laid out will guide you. For most teams, the days of paying for LocalStack or settling for incomplete mocks are over. Trial both, and see which fits your workflow. ## FAQ ### Is MiniStack completely free? Yes. MiniStack is MIT-licensed with no paid tiers, no API keys, and no telemetry. ### Does MiniStack support RDS and ElastiCache? Yes — MiniStack spins up real PostgreSQL, MySQL, and Redis containers for RDS and ElastiCache, unlike LocalStack Free which moved these services to its paid tier. ### How does MiniStack compare to LocalStack in performance? MiniStack starts in ~2 seconds vs. 15–30 seconds for LocalStack, and uses ~30MB RAM at idle vs. ~500MB. ### Can I use MiniStack with Terraform, CDK, or Pulumi? Yes. MiniStack is endpoint-compatible with all major AWS SDKs and IaC tools. You only need to override the endpoint URL to http://localhost:4566. ### Is MiniStack production-ready? MiniStack is stable for local development and CI/CD pipelines. It has 900+ tests and is actively maintained, but it is still a young project — verify your specific service requirements before migrating from LocalStack. ### Is floci completely free? Yes. floci is MIT-licensed with no account, API key, or feature gates. No authentication or telemetry. ### How does floci compare to MiniStack? floci starts in ~24ms with 13 MiB RAM (vs. MiniStack at 2s and 30MB). MiniStack covers 38 services; floci covers 40+. Both are MIT-licensed and free. Choose floci for speed-critical CI; choose MiniStack for broader service breadth or Python tooling preference. --- *Source: https://www.factualminds.com/blog/ministack-free-localstack-alternative-aws-emulator/*