Oracle Cloud on localhost:4599

A free, MIT-licensed Oracle Cloud Infrastructure emulator. Give your coding agents a real OCI to build and test against: no Oracle Cloud account, no uploaded API keys, no bill.

Get started floci-oci on GitHub

# Install floci-cli, then start floci-oci
curl -fsSL https://floci.io/install.sh | sh
floci oci start
floci oci setup
eval $(floci oci env)

8 OCI services ready on :4599. Object Storage · Queue · Streaming · KMS · Vault · +3 more

24 ms startup · ~13 MiB idle · MIT licensed · no Oracle Cloud account

Homebrew, Windows and Docker options

Quick Start

Every way to run it.

One CLI installs and runs all four emulators: use Homebrew, the install script or PowerShell. Or skip the CLI and run the Docker image.

1 · Install floci CLI

brew install floci-io/floci/floci

curl -fsSL https://floci.io/install.sh | sh

iwr https://floci.io/install.ps1 | iex

2 · Start the emulator

floci oci start

3 · One-time setup & env vars

# creates a throwaway API key + ~/.oci/config profile
floci oci setup
eval $(floci oci env)
export TENANCY_OCID=ocid1.tenancy.oc1..flocilocaltenancy0000000000000000000000000000000000000000

4 · Upload a file

# Create a bucket
oci os bucket create \
  --namespace-name floci-local \
  --name my-bucket \
  --compartment-id $TENANCY_OCID

# Write a file and upload it
echo "Oracle Cloud locally: no bill, no drama." \
  > hello-floci.txt
oci os object put \
  --namespace-name floci-local \
  --bucket-name my-bucket \
  --file hello-floci.txt

# Download it back and read it
oci os object get \
  --namespace-name floci-local \
  --bucket-name my-bucket \
  --name hello-floci.txt \
  --file hello-back.txt
cat hello-back.txt

Teach your coding agent

# Asks which agents to install it for
npx skills add floci-io/floci-cli

The Floci skill teaches Claude Code, Codex, Cursor, Kiro and other coding agents to run the emulators with floci-cli.

Other useful commands

# Check status
floci oci status

# View logs
floci oci logs

# Stop the emulator
floci oci stop

# List enabled OCI services
floci oci services

# Poll until ready (CI-friendly)
floci oci wait

Start with persistence

floci oci start --persist ./data
# state survives container restarts

Diagnose issues

floci oci doctor
# checks Docker, OCI CLI, connectivity

Examples

Python, Java and the OCI CLI.

Use the standard OCI SDK in any language and point it at localhost:4599.

 # pip install oci
 import oci

config = {

  "user": "ocid1.user.oc1..anyuser",

  "fingerprint": "aa:bb:cc:dd:ee:ff:00:11:22:33:44:55:66:77:88:99",

  "tenancy": "ocid1.tenancy.oc1..flocilocaltenancy0000000000000000000000000000000000000000",

  "region": "us-ashburn-1",

  "key_file": "~/.oci/floci_key.pem", # any locally generated key
 }

client = oci.object_storage.ObjectStorageClient(

  config, service_endpoint="http://localhost:4599")

namespace = client.get_namespace().data

try:

    client.create_bucket(namespace, oci.object_storage.models.CreateBucketDetails(

        name="python-bucket", compartment_id=config["tenancy"]))

except oci.exceptions.ServiceError as e:

    if e.status != 409: # 409: created on an earlier run

        raise

client.put_object(namespace, "python-bucket", "hello.txt", b"Hello from floci-oci!")

 // com.oracle.oci.sdk:oci-java-sdk
 var auth = SimpleAuthenticationDetailsProvider.builder()

  .tenantId("ocid1.tenancy.oc1..flocilocaltenancy0000000000000000000000000000000000000000")

  .userId("ocid1.user.oc1..anyuser")

  .fingerprint("aa:bb:cc:dd:ee:ff:00:11:22:33:44:55:66:77:88:99")

  .privateKeySupplier(new SimplePrivateKeySupplier(

    System.getProperty("user.home") + "/.oci/floci_key.pem"))

  .region(Region.US_ASHBURN_1)

  .build();

ObjectStorageClient client = ObjectStorageClient.builder().build(auth);

client.setEndpoint("http://localhost:4599");

String namespace = client.getNamespace(GetNamespaceRequest.builder().build()).getValue();

try {

client.createBucket(CreateBucketRequest.builder()

  .namespaceName(namespace)

  .createBucketDetails(CreateBucketDetails.builder()

    .name("java-bucket").compartmentId(auth.getTenantId()).build())

  .build());

} catch (BmcException e) {

  if (e.getStatusCode() != 409) throw e; // 409: created on an earlier run

}

 # Every OCI CLI command works with --endpoint
 oci os ns get --endpoint http://localhost:4599

oci iam compartment list \

  --endpoint http://localhost:4599 \

  --compartment-id ocid1.tenancy.oc1..flocilocaltenancy0000000000000000000000000000000000000000

 # Or let the floci CLI wire the endpoint for you

floci oci setup && eval $(floci oci env)

oci os ns get

Default connection values

floci-oci parses request signatures for tenancy and user context but never verifies them, so any locally generated API key works.

Property	Value
Endpoint	`http://localhost:4599`
Namespace	`floci-local`
Tenancy OCID	`ocid1.tenancy.oc1..flocilocaltenancy0000000000000000000000000000000000000000`
Region	`us-ashburn-1`
API key	`any locally generated RSA key`
Health check	`http://localhost:4599/_floci-oci/health`

floci-oci · OCI services

8 OCI services. All of them free.

Wire-compatible with the official OCI SDKs, the OCI CLI, Terraform and OpenTofu. Point your existing tools at localhost and keep your workflows.

Object Storage REST JSON · multipart / PAR Functions REST JSON · Fn Project OKE REST JSON · k3s Queue REST JSON · DLQ / channels Streaming REST JSON · cursors / groups Identity (IAM) REST JSON · work requests KMS REST JSON · real AES / RSA / ECDSA Vault Secrets REST JSON · secret bundles

Runs a Docker container

Why floci-oci

No account. No key ceremony.

Object Storage, Queue, Streaming, KMS, Vault, Functions and OKE on one port, with throwaway keys in place of real credentials.

Any key works

Request signatures are parsed for tenancy and user context but never verified, so any locally generated API key works with the OCI SDKs, the OCI CLI, Terraform and OpenTofu.

Real crypto, real Functions

KMS performs real AES-GCM, RSA and ECDSA operations. Functions invocations run your real FDK image through an Fn Project sidecar, not a mock.

One port, few containers

Every service answers on port 4599. Functions and OKE launch Docker containers; the other 6 services run entirely in-process.

Native-image speed

Starts in 24 ms and idles at ~13 MiB, fast enough to start a fresh emulator for every test run.

No key ceremony. No bill.

MIT licensed and built for developer workflows. No Oracle Cloud account, no uploaded API keys, no credit card. Just floci-cli and localhost.

floci-oci on GitHub

Other emulators: AWS Azure GCP

license: MIT
real credentials: none
cloud account: none
cost: $0