# Example Projects Using denoland/celld: 16 Ready-to-Run Demos

> Explore 16 production-ready example projects using denoland/celld. Discover Durable Object API features from WebSockets to Wasm in these ready-to-run demos.

- Repository: [Deno/celld](https://github.com/denoland/celld)
- Tags: getting-started
- Published: 2026-09-05

---

**The celld repository includes 16 production-ready example projects in the `examples/` directory**, each demonstrating specific Durable Object API capabilities from basic Workers to WebSockets, databases, and Wasm.

Every example is a standalone Wrangler-compatible project that deploys with a single `celld deploy .` command. Whether you're building stateless edge handlers or complex multi-step workflows, these samples provide copy-paste starting points for the celld runtime.

## What Are the celld Example Projects?

The `examples/` directory contains curated projects that progressively expose celld's surface area. Each example is a complete, runnable application—not snippets—stored in its own subdirectory with [`index.js`](https://github.com/denoland/celld/blob/main/index.js) and configuration files.

As implemented in denoland/celld, the examples cover:

- Core Worker patterns (fetch handlers, routing, bodies)
- Storage backends (SQLite, D1, KV, R2)
- Real-time features (WebSocket server/client, alarms)
- Advanced capabilities (vector search, Wasm, RPC, workflows)

All examples support `celld dev` for local testing and `celld deploy .` for production deployment to an S3-compatible bucket.

## Stateless Worker Examples

### Hello: Minimal Fetch Handler

[`examples/hello/index.js`](https://github.com/denoland/celld/blob/main/examples/hello/index.js) shows the simplest possible celld Worker:

```js
export default {
  async fetch(request, env) {
    return new Response("Hello from cells! url=" + request.url, { status: 200 });
  },
};

```

This demonstrates the entry point signature all celld Workers use: an object with a `fetch` method receiving `request` and `env` parameters.

### Webapi: Platform APIs in Workers

[`examples/webapi/index.js`](https://github.com/denoland/celld/blob/main/examples/webapi/index.js) exercises standard Web Platform APIs (`fetch`, `Headers`, `URL`) inside the celld runtime, confirming compatibility with browser-standard patterns.

### Body: Streaming Request Handling

[`examples/body/index.js`](https://github.com/denoland/celld/blob/main/examples/body/index.js) handles streaming request bodies and custom response construction—essential for upload endpoints or proxy services.

## Storage and Database Examples

### Counter: SQLite-Backed Durable Object

[`examples/counter/index.js`](https://github.com/denoland/celld/blob/main/examples/counter/index.js) implements the canonical Durable Object pattern: persistent state backed by SQLite with LTX log replication. This shows how celld maintains strong consistency across geographic regions.

### KV: Key-Value CRUD Operations

[`examples/kv/index.js`](https://github.com/denoland/celld/blob/main/examples/kv/index.js) demonstrates the KV binding with full CRUD:

```js
export default {
  async fetch(request, env) {
    const key = new URL(request.url).pathname.slice(1);
    if (!key) return new Response("Use /KEY.", { status: 400 });

    if (request.method === "PUT") {
      await env.VALUES.put(key, request.body);
      return new Response(null, { status: 204 });
    }

    if (request.method === "DELETE") {
      await env.VALUES.delete(key);
      return new Response(null, { status: 204 });
    }

    const value = await env.VALUES.get(key);
    return value === null
      ? new Response("Not found.", { status: 404 })
      : new Response(value);
  },
};

```

### D1: Cloudflare D1 Integration

[`examples/d1/index.js`](https://github.com/denoland/celld/blob/main/examples/d1/index.js) builds a guestbook application using D1, Celld's SQLite-compatible database service for complex relational queries.

### R2: Object Storage Operations

[`examples/r2/index.js`](https://github.com/denoland/celld/blob/main/examples/r2/index.js) exercises read, write, and delete operations against R2 buckets—celld's S3-compatible object storage.

## Specialized Data Examples

### Vectordb: Per-Object Vector Search

[`examples/vectordb/index.js`](https://github.com/denoland/celld/blob/main/examples/vectordb/index.js) showcases the `vec0` extension for embedding-powered nearest-neighbor search, implemented as a per-Durable-Object index for color lookup scenarios.

### Async: Timers and Alarms

[`examples/async/index.js`](https://github.com/denoland/celld/blob/main/examples/async/index.js) combines `setTimeout`-based delays with asynchronous storage operations, demonstrating non-blocking patterns in long-lived Durable Objects.

## WebSocket and Real-Time Examples

### Wsecho: WebSocket Server with Hibernation

[`examples/wsecho/index.js`](https://github.com/denoland/celld/blob/main/examples/wsecho/index.js) implements an echo server that **hibernates idle sockets**—a celld optimization that frees memory while preserving connection state.

### Wsclient: Outbound WebSocket Connections

[`examples/wsclient/index.js`](https://github.com/denoland/celld/blob/main/examples/wsclient/index.js) shows a Durable Object acting as a client to external WebSocket servers, enabling bidirectional real-time bridges.

### Alarm: Scheduled Tasks

[`examples/alarm/index.js`](https://github.com/denoland/celld/blob/main/examples/alarm/index.js) configures Durable Object alarms for time-based execution without external triggers.

### Cron: Periodic Triggers

[`examples/cron/index.js`](https://github.com/denoland/celld/blob/main/examples/cron/index.js) demonstrates cron-like scheduled execution for recurring background work.

## Architecture Pattern Examples

### Router: Worker-to-DO Routing

[`examples/router/index.js`](https://github.com/denoland/celld/blob/main/examples/router/index.js) implements clean separation between stateless Workers and stateful Durable Objects, with request routing logic that scales horizontally.

### RPC: Method-Call Style Communication

[`examples/rpc/index.js`](https://github.com/denoland/celld/blob/main/examples/rpc/index.js) replaces raw HTTP with ergonomic JavaScript RPC, letting callers invoke DO methods as if they were local functions.

### Workflow: Multi-Step Durable Processing

[`examples/workflow/index.js`](https://github.com/denoland/celld/blob/main/examples/workflow/index.js) chains multiple durable steps into a single logical job with fault tolerance and exactly-once execution semantics.

## Advanced: WebAssembly Integration

### Wasm: Rust-Compiled Durable Object

[`examples/wasm/README.md`](https://github.com/denoland/celld/blob/main/examples/wasm/README.md) documents building a Durable Object from Rust-compiled WebAssembly. Unlike other examples, this requires a build step:

```sh

# Per the wasm example README

cargo build --target wasm32-wasi --release
celld deploy .

```

This enables compute-intensive workloads or reuse of existing Rust libraries in the celld environment.

## Deploying Any Example

The deployment pattern is identical across all 16 projects:

```sh
cd examples/counter  # or any example directory

celld deploy . --bucket s3://my-cells-bucket

```

For local development without cloud resources:

```sh
celld dev

```

This starts a local celld node serving the example directly.

## Key Example Files Reference

| File Path | Purpose |
|-----------|---------|
| [`examples/README.md`](https://github.com/denoland/celld/blob/main/examples/README.md) | Master index of all examples with descriptions |
| [`examples/hello/index.js`](https://github.com/denoland/celld/blob/main/examples/hello/index.js) | Minimal starting point |
| [`examples/counter/index.js`](https://github.com/denoland/celld/blob/main/examples/counter/index.js) | SQLite DO state pattern |
| [`examples/kv/index.js`](https://github.com/denoland/celld/blob/main/examples/kv/index.js) | KV binding reference |
| [`examples/wsecho/index.js`](https://github.com/denoland/celld/blob/main/examples/wsecho/index.js) | WebSocket hibernation |
| [`examples/wsclient/index.js`](https://github.com/denoland/celld/blob/main/examples/wsclient/index.js) | Outbound WebSocket client |
| [`examples/router/index.js`](https://github.com/denoland/celld/blob/main/examples/router/index.js) | Worker/DO routing architecture |
| [`examples/r2/index.js`](https://github.com/denoland/celld/blob/main/examples/r2/index.js) | Object storage patterns |
| [`examples/d1/index.js`](https://github.com/denoland/celld/blob/main/examples/d1/index.js) | Relational database integration |
| [`examples/vectordb/index.js`](https://github.com/denoland/celld/blob/main/examples/vectordb/index.js) | Vector search implementation |
| [`examples/rpc/index.js`](https://github.com/denoland/celld/blob/main/examples/rpc/index.js) | RPC-over-HTTP pattern |
| [`examples/workflow/index.js`](https://github.com/denoland/celld/blob/main/examples/workflow/index.js) | Multi-step durable jobs |
| [`examples/wasm/README.md`](https://github.com/denoland/celld/blob/main/examples/wasm/README.md) | WebAssembly build instructions |

## Summary

- **16 complete example projects** ship with denoland/celld in the `examples/` directory
- Each example is a **deployable Wrangler project** using `celld deploy . --bucket s3://...`
- Coverage spans **stateless Workers, SQLite DOs, databases, WebSockets, vector search, RPC, workflows, and Wasm**
- **Local development** via `celld dev` requires no cloud bucket
- All source files follow consistent patterns that transfer directly to production applications

## Frequently Asked Questions

### Where are the celld example projects located?

All example projects live in the `examples/` directory at the root of the denoland/celld repository. Each subdirectory contains a complete, runnable application with [`index.js`](https://github.com/denoland/celld/blob/main/index.js) and any required configuration.

### Do I need Cloudflare to run celld examples?

No. The examples work with any S3-compatible bucket using `celld deploy . --bucket s3://...`. For local development, `celld dev` runs examples without any cloud dependency.

### Which example should I start with as a beginner?

Begin with [`examples/hello/index.js`](https://github.com/denoland/celld/blob/main/examples/hello/index.js) for the simplest Worker pattern, then progress to [`examples/counter/index.js`](https://github.com/denoland/celld/blob/main/examples/counter/index.js) to understand Durable Object state. The [`examples/README.md`](https://github.com/denoland/celld/blob/main/examples/README.md) file lists all examples in recommended learning order.

### Can I use these examples in production?

Yes. The examples are production-grade patterns extracted from real celld usage. They include proper error handling, hibernation for WebSockets, and SQLite transaction patterns suitable for high-traffic deployments.