Go Developers, Meet the New Ratio1 SDK and Sandbox

While Ratio1’s platform initially focused on Python (with Node.js as the first expansion beyond that ecosystem), we’re now excited to bring first-class support to Go developers. Today we are shipping two tightly coupled projects that make building on Ratio1 feel native in Go: edge_sdk_go, our idiomatic Go SDK for the CStore and R1FS services on every Ratio1 edge node, and r1-plugins-sandbox, a plug-and-play local twin of those services for development. Together they give your team a frictionless path from prototype to production on the Ratio1 stack - no custom shims, no guesswork, and no live infrastructure required while you iterate.

Built side by side, the SDK and sandbox mirror the same primitives that power Ratio1 edge nodes in the field. CStore behaves like a Redis-inspired key/value store with optimistic concurrency, while R1FS brings IPFS-style content addressing and artifact management into your workflow. With the Go SDK you can talk to both with just a few lines of code. With the sandbox, you can exercise every edge-node API from any language, right on your laptop, with predictable fixtures and even optional chaos-testing knobs at your disposal.

Meet edge_sdk_go: CStore and R1FS at Your Fingertips

The SDK lives in the edge_sdk_go GitHub repository and it ships with batteries included:

• Easy bootstrapping: Use cstore.NewFromEnv() and r1fs.NewFromEnv() to initialize ready-to-use clients from the standard EE_CHAINSTORE_API_URL and EE_R1FS_API_URL environment variables (the endpoints for CStore and R1FS). No manual config needed.

• Familiar data operations: The clients expose intuitive methods. For example, CStore offers Set, Get, HSet, HGetAll, etc., and R1FS provides methods like AddFile, AddFileBase64, AddYAML, GetFile, GetYAML, CalculateJSONCID, and more – all following patterns you’d expect.

• Context-aware requests: Every request method accepts a context.Context, making cancellation and deadlines first-class citizens for your pipelines and background workers.

Below is a quick taste of using the SDK in Go (error handling abbreviated for brevity):

ctx := context.Background()
cs, _ := cstore.NewFromEnv()  // bootstrap CStore client from env
fs, _ := r1fs.NewFromEnv()    // bootstrap R1FS client from env

_ = cs.Set(ctx, "jobs:123", map[string]any{"status": "queued"}, nil)
// -> stores a JSON-serializable value under the key "jobs:123"

cid, _ := fs.AddYAML(ctx, map[string]any{"service": "r1fs"}, nil)
log.Printf("Stored artifact with CID %s", cid)
// -> adds a YAML document to R1FS and logs its content-addressed CID

The SDK’s examples/ directory doubles as a living integration test suite and tutorial. Run go run ./examples/cstore to walk through optimistic writes, hash operations, and status checks. Likewise, go run ./examples/r1fs uploads some content to R1FS and then retrieves it, illustrating how content-addressed storage works in practice. This blend of code and documentation is intentional – we want the path from “hello world” to a production-ready service to be as short as possible for Go developers.

Spin Up r1-plugins-sandbox in Minutes

Shipping a polished SDK is only half the story. Real developer velocity also requires an environment you can spin up instantly, share with teammates, and wire into automated tests. That’s where r1-plugins-sandbox comes in.

The sandbox is a small Go binary that mirrors the CStore and R1FS REST APIs (the same FastAPI plugins that run on live Ratio1 edge nodes). Launch it with a single command and it prints out the environment exports your clients expect:

$ ./r1-plugins-sandbox --cstore-addr :8787 --r1fs-addr :8788

export EE_CHAINSTORE_API_URL=http://127.0.0.1:8787
export EE_R1FS_API_URL=http://127.0.0.1:8788

Set those environment variables in your shell, and now any Ratio1 SDK client (Go or otherwise) will automatically talk to your local sandbox instead of a live node. From there, you can point any language or tool at localhost and exercise the complete API surface: optimistic key/value operations, hash map fields, binary file uploads, content-addressed retrievals, CID calculations - you name it.

Because the sandbox exposes the same HTTP endpoints as a real node, it’s completely language-agnostic. You can use the official Go SDK, the Ratio1 NodeJS/TypeScript SDK (edge-sdk-ts), a Python script, or even just curl – the behavior will be identical. This makes the sandbox an ideal bridge for teams experimenting with Ratio1 primitives from different stacks, all while keeping tests hermetic and reproducible.

The sandbox is also configurable to simulate real-world conditions. Need consistent test data? Seed deterministic key/value entries with the --kv-seed flag and preload files with --fs-seed. Want to test your code’s resilience to slow networks or flaky nodes? Add artificial latency with --latency 200ms or inject failures using --fail rate=0.1,code=503 (meaning ~10% of requests will return an HTTP 503 error). These options let you dial up the chaos to ensure your retry and timeout logic is rock-solid before you ever hit production.

Getting Started

Getting started with Ratio1’s Go tools is straightforward:

1. Install the SDK: Add the Go module to your project with go get github.com/Ratio1/edge_sdk_go. Import the pkg/cstore and pkg/r1fs packages in your code to access the clients.

2. Download the Sandbox: Head over to the r1-plugins-sandbox releases page and grab the binary for your platform (Linux, macOS, Windows are all available). Unpack it and put r1-plugins-sandbox in your $PATH.

3. Run the Sandbox: Start the sandbox locally (./r1-plugins-sandbox) and export the EE_CHAINSTORE_API_URL and EE_R1FS_API_URL variables it prints out. This ensures the SDK knows how to find your local sandbox services.

4. Use the Examples or Your Code: Try the provided example programs (go run ./examples/...) to verify everything is working end-to-end. Then integrate the Ratio1 SDK into your own Go service by using cstore.NewFromEnv() and r1fs.NewFromEnv() - when you’re ready to go live, just change the environment variables to point to a real Ratio1 edge node and your code won’t need any other changes.

(Integration from other languages is easy too: you can hit the sandbox’s HTTP APIs directly or use our official TypeScript SDK for NodeJS. Everything the sandbox does locally mirrors the behavior of live edge nodes, so you can prototype in any environment.)

In deployment scenarios, you can even keep the sandbox wired into your CI pipeline to run end-to-end tests on every commit. Once you’re satisfied, deploy your code to actual Ratio1 edge nodes; the Go SDK will automatically use the environment variables provided by the node, and your app will seamlessly transition from local sandbox to live infrastructure. This zero-diff swap between sandbox and production is intentional: the routes, payloads, and responses are identical.

What’s Next

This release is a major step toward making Ratio1 development feel native across languages, frameworks, and team sizes. Grab the Go SDK, spin up the sandbox, and show us what you build! Whether you’re running offline batch jobs, chaining AI model inference, or developing a partner integration, we can’t wait to see how you bring Ratio1’s primitives to life in Go  -  and beyond.

As always, we invite you to join the Ratio1 developer community (Discord and other channels) and share your feedback. Let us know how you’re using the new tools and which features you’d like to see prioritized next. Your workflows and ideas will help shape where the platform goes from here. Happy coding!