Imagine youβre building a backend application that uses AWS S3 for file storage, SQS for messaging, DynamoDB for persistence, and Lambda for background processing.
Everything works during development until you need to test the actual cloud integrations.
You create an AWS account, configure credentials, set up cloud resources, deploy your application, and spend time cleaning up resources after every test. Your development workflow now depends on external infrastructure.
For a small feature, thatβs a lot of overhead.
What if you could run these cloud services locally, connect your existing SDKs and CLIs to them, and test your application without touching a real cloud account?
Thatβs where local cloud emulators come in.
Developers have used tools such as LocalStack, Moto, and Azurite for years to emulate individual cloud services. However, a newer open-source project called Floci is taking a broader approach: providing local emulators for AWS, Microsoft Azure, Google Cloud Platform, and Oracle Cloud Infrastructure.
Letβs look at how it works, what it supports, and how you can use it in your development workflow.
What are local cloud emulators?
A local cloud emulator recreates the API behavior of cloud services on your development machine.
Your application communicates with the emulator through an endpoint such as http://localhost:4566 instead of connecting to AWS infrastructure.
Your existing SDKs, CLI tools, and application code can interact with the local implementation.
Consider this architecture:
Traditional cloud development
Application
|
v
Cloud SDK
|
v
Internet
|
v
AWS / Azure / GCP
|
v
Cloud ResourcesWith a local cloud emulator:
Local cloud development
Application
|
v
Cloud SDK
|
v
localhost
|
v
Local Cloud Emulator
|
v
Local ServicesThis gives developers a way to test cloud-dependent application behavior without provisioning real cloud infrastructure for every development cycle.
There is an important distinction between mocking and emulation.
A mock generally returns predetermined responses or implements a limited interface for testing. An emulator accepts service-compatible requests and implements the corresponding API behavior, often maintaining resource state.
The depth of emulation depends on the service and the operations implemented.
Meet Floci: One open-source ecosystem for fourΒ clouds

GitHub: floci-io
Website: floci.io
Floci is an open-source local cloud emulator ecosystem designed for application development, testing, and CI.
Its approach is straightforward: run cloud-compatible services locally and connect your existing development tools to them.
The ecosystem currently contains four separate emulators.

Each emulator runs independently. You can start one provider or run multiple providers side by side.
The projects are available on GitHub:
Letβs look at what each emulator brings.
1. Floci: AWS local cloudΒ emulator
GitHub: floci-io/floci
Floci is the AWS emulator in the ecosystem and an alternative to LocalStack.
It supports a broad range of AWS services, including:

Other supported services include Step Functions, CloudWatch, Route 53, ECR, and several analytics and AI services.
The interesting part is the approach to service implementation.
Some services use actual underlying engines. For example, Lambda executes functions in Docker containers, RDS uses real PostgreSQL and MySQL instances, and ElastiCache uses Redis-compatible infrastructure.
This gives developers more realistic behavior for those services than a simple collection of predetermined responses.
Floci exposes AWS services through a common endpoint:
http://localhost:4566Your existing AWS SDKs and CLI commands can target this endpoint.
2. Floci AZ: Local AzureΒ emulator
GitHub: floci-az
Azure developers also get a dedicated local emulator.
Floci AZ supports services such as:
Blob, Queue, and Table Storage
Cosmos DB
Azure Functions
Key Vault
Event Hubs
Service Bus
Azure SQL Database
Azure Kubernetes Service
It provides a common local endpoint:
http://localhost:4577One useful feature is compatibility with existing Azure development tools.
You can configure your Azure SDK, Azure CLI, or Terraform provider to communicate with the local emulator.
For developers already familiar with Azurite, Floci AZ also provides a wider set of Azure services beyond the storage services that Azurite focuses on.
This makes it worth investigating when your application depends on multiple Azure services.
3. Floci GCP: Local Google CloudΒ emulator
GitHub: floci-gcp
Google Cloud developers get their own emulator through Floci GCP.
Some supported services include:
Cloud Storage
Pub/Sub
Firestore
Datastore
Secret Manager
IAM
Managed Kafka
The local endpoint is:
http://localhost:4588You can use supported GCP SDKs and gcloud CLI commands against this endpoint.
For example, creating a local storage bucket can use the familiar Google Cloud command:
gcloud storage buckets create gs://demo-bucketThis is useful when developing event-driven applications that rely on Google Cloud Storage, Pub/Sub, and other supported services.
4. Floci OCI: Local Oracle CloudΒ emulator
GitHub: floci-oci
Oracle Cloud Infrastructure is another provider included in the ecosystem.
Floci OCI supports several OCI services:
Object Storage
Queue
Streaming
Identity and compartments
Vault and Key Management
Secrets
Functions
Container Engine for Kubernetes
The local endpoint is:
http://localhost:4599It works with the OCI CLI, supported OCI SDKs, Terraform, and OpenTofu.
One interesting detail is that OCI request compatibility includes features such as OCIDs, pagination headers, ETags, work requests, and OCI-compatible error responses.
For developers working with Oracle Cloud, having a local environment for these integrations can reduce dependency on an actual OCI tenancy during development.
π‘ Enjoying this article?
Every week day, I publish practical, production-ready deep dives covering Web development, System Design, Open source projects, Tech industry trends and AI Engineering and tools.
Getting started withΒ Floci
You donβt need to manually configure every container and environment variable.
Floci provides an official CLI that manages the emulator lifecycle.
Step 1: Install FlociΒ CLI
On macOS or Linux with Homebrew:
brew install floci-io/floci/flociYou can also install it using the installation script:
curl -fsSL https://floci.io/install.sh | shRepository: floci-cli
Step 2: Start your local AWS environment
Run:
floci startThe CLI pulls the required Docker image if necessary, starts the emulator, and waits for it to become ready.
Step 3: Configure AWSΒ CLI
Execute:
eval "$(floci env)"This configures the environment variables needed to communicate with the local AWS emulator.
Step 4: Create your first S3Β bucket
Now use your existing AWS CLI commands:
aws s3 mb s3://demo-bucket
aws s3 lsThatβs it. You have created an S3 bucket against your local emulator.
Your application can use its normal AWS SDK configuration, pointing requests at the local endpoint.
Step 5: Try other cloud providers
The CLI exposes separate commands for each provider.
# Google Cloud
floci gcp start
eval "$(floci gcp env)"
# Azure
floci az start
floci az setup
eval "$(floci az env)"
# Oracle Cloud
floci oci start
floci oci setup
eval "$(floci oci env)"You can also run the emulator with persistent local storage:
floci start --persist ./dataUseful lifecycle commands include:
floci status
floci logs
floci stopThe CLI manages emulator containers and configuration. Your regular cloud CLI tools remain responsible for creating and managing cloud resources.
Two additional projects worth exploring
The Floci ecosystem includes supporting tools beyond the four emulators.
Floci UI: Manage resources through aΒ browser
GitHub: floci-ui
Working entirely through the terminal becomes inconvenient when you have several local resources to inspect.
Floci UI provides a browser-based console for AWS, Azure, GCP, and OCI.
You can launch the multi-cloud environment using:
docker compose --profile multicloud upThen open:
http://localhost:4500One architectural detail is worth mentioning: Floci UI does not emulate cloud services itself. Its API sends requests through the cloud SDKs to the emulators, and the interface displays the responses returned by those services.
That means the UI reflects actual emulator responses rather than generating demonstration resource records.
Floci Duck: SQL execution usingΒ DuckDB
GitHub: floci-duck
Floci Duck is an additional component for developers working with data and analytics.
It uses DuckDB as its SQL execution engine and supports S3-compatible storage through its HTTP filesystem extension.
Some of its capabilities include:
Athena-style query execution with CSV results exported to S3.
Firehose-style SQL execution.
S3 Select-style queries returning JSON.
Reading and writing Parquet files directly to S3.
It is particularly relevant when your local application uses AWS analytics services and you need to exercise SQL-based workflows.
What should developers consider before using cloud emulators?
Local cloud emulators can make development much easier, but there are a few engineering considerations.
1. Check API compatibility service by service.
An emulator can advertise support for a service while implementing only a subset of its operations. Check the actual compatibility documentation for the operations your application uses.
2. Understand authentication differences.
Floci is designed to work without real cloud credentials. For example, its AWS setup can accept non-empty test credentials. This is convenient locally, but authentication behavior may differ from production IAM and identity policies.
3. Be careful with Docker socket access.
Some services need Docker access to launch containers for workloads such as Lambda. Mounting the Docker socket gives the emulator control over the host container daemon. Use this only in an environment where that access is appropriate.
4. Keep integration tests against the real cloud.
Local emulation cannot guarantee identical behavior for every managed service, IAM policy, quota, networking configuration, or regional feature.
Use local emulators for rapid feedback and repeatable development. Keep a separate integration-testing stage against the actual cloud provider before production deployments.
Final thoughts
Local cloud emulation is becoming an increasingly useful part of modern development workflows.
For developers working with AWS, Azure, GCP, or OCI, Floci offers an interesting open-source ecosystem worth exploring. Having separate provider emulators with a shared CLI and browser console makes it easier to experiment with cloud services without provisioning a real cloud environment for every development task.
Iβd start with one provider and the services your application actually needs. Get the SDK integration working, add the emulator to your local Docker workflow, and then introduce it into CI.
You can explore the complete ecosystem here:
GitHub: Floci-IO
Website: Floci
Thank You forΒ Reading!
I hope you found it helpful and informative. If you have any questions or feedback, feel free to leave a comment below. Your support and engagement mean a lot to me.
