# Cloudflare Void: Open-Source SDK, CLI, and Platform for Full-Stack Vite Apps on Workers

Void is Cloudflare/VoidZero’s open-source SDK, CLI, and self-hosted platform for building full-stack Vite apps and deploying them to Cloudflare Workers with zero-config resources.

Canonical URL: https://aiidelist.com/blog/cloudflare-void-open-source-vite-deployment

Language: en

Published: 2026-10-15

Updated: 2026-10-15

## Key Takeaways

- **Void** is an open-source SDK, CLI, and self-hosted Platform from VoidZero (now part of Cloudflare) for building full-stack Vite apps and deploying them to Cloudflare Workers.
- The **SDK** turns a Vite app into a Cloudflare Workers app with file-based routing, end-to-end type safety (database to UI), and automatic resource inference (D1, queues, AI, storage).
- The **CLI** (`void deploy`) builds with Vite, applies migrations, provisions Cloudflare resources, and deploys in one command; it also supports agent-driven lifecycle management.
- The **Platform** lets teams self-host a shared deployment environment on Workers for Platforms with access controls, resource limits, and isolation—without handing out full account keys.
- Supports React, Vue, Svelte, Solid adapters plus meta-frameworks (TanStack Start, SvelteKit, Nuxt, React Router, Astro). Local development mirrors production bindings.
- Open-sourced October 15, 2026 under MIT; install with `npm install void` and initialize via `npx void init`.

![Image](https://cdn.aiidelist.com/api/image/4AMfaYugVj3j6uRN2o7Cm.webp)

## What Is Void?

On October 15, 2026, Cloudflare announced Void—an open-source full-stack development and deployment platform built by the VoidZero team (creators of Vite, Vitest, Rolldown, Oxc, and Vite+). VoidZero joined Cloudflare in June 2026; this release open-sources the internal platform they had been using in production.

Void consists of three tightly integrated pieces distributed as a single JavaScript package and Vite plugin:

- **Void SDK** — Composable toolkit that turns a Vite project into a full-stack Cloudflare Workers application.
- **Void CLI** — Command-line interface for provisioning resources, deploying, inspecting logs, rolling back, and managing platforms. Built on Cloudflare’s newer `cf` CLI and designed for both humans and coding agents.
- **Void Platform** — Self-hosted multi-tenant deployment environment that runs inside a Cloudflare account on Workers for Platforms. Teams get shared infrastructure with admin-controlled access, quotas, and auditability.

The core promise is a unified Vite workflow: write server and client code together, carry types from the database schema all the way to the UI, and let the tooling automatically provision the Cloudflare resources the app actually uses.

## How the Void SDK Works

The SDK is intentionally optional and composable. You can use Void’s own pages mode and file-based routing, or keep an existing Vite-based meta-framework and let Void handle resource APIs, migrations, and deployment.

A minimal Vite configuration looks like this:

```ts
import { defineConfig } from "vite";
import { voidPlugin } from "void";
import { voidReact } from "@void/react/plugin";

export default defineConfig({
  plugins: [voidPlugin(), voidReact()],
});
```

Server-side data loading with end-to-end types is straightforward:

```ts
// pages/blog.server.ts
import { defineHandler, type InferProps } from "void";
import { db } from "void/db";
import { posts } from "@schema";

export const loader = defineHandler(async () => ({
  posts: await db.select().from(posts),
}));

export type Props = InferProps<typeof loader>;
```

```tsx
// pages/blog.tsx
export default function Blog({ posts }: Props) {
  return (
    <ul>
      {posts.map((post) => <li key={post.id}>{post.title}</li>)}
    </ul>
  );
}
```

During development, `void/db`, `void/ai`, and similar imports resolve to local resources. On deploy, Void infers the required bindings and provisions real Cloudflare resources (D1 databases, queues, AI Gateway, etc.). Authentication is available via Better Auth. The SDK also supports islands architecture, pre-rendering, caching, and cron/queue consumers.

Supported UI layers include Async React (with transitions and Suspense), Vue, Svelte, and Solid. Framework integrations cover TanStack Start, SvelteKit, Nuxt, React Router, and Astro. Non-Cloudflare targets (Node, Bun, Deno) are supported for local or self-hosted server modes, though Cloudflare-specific bindings are compile-time restricted outside the Workers target.

## Void CLI: One-Command Deploy and Agent-Friendly Lifecycle

The CLI is the primary interface for both developers and coding agents. After initializing a project (`npx void init`) and choosing a framework plus starter, deployment is a single command:

```bash
npx void deploy
```

On first run it opens a browser for Cloudflare login. Subsequent runs build with Vite, apply database migrations, provision inferred resources, and print the live Worker URL. Team platforms are targeted with:

```bash
npx void connect https://api.your-company.dev
npx void deploy
```

The CLI also exposes platform administration (users, projects, deployments, logs, rollbacks, health) and is explicitly designed so agents can debug failing requests, analyze performance, or handle the full deploy lifecycle. A minimal `AGENTS.md` is generated during init to help coding agents understand the project.

## Void Platform: Controlled Team Deployments on Workers for Platforms

The Platform is the piece that addresses a common operational pain: “you can deploy this app” should not mean “here are the keys to the production Cloudflare account.”

It installs into an existing Cloudflare account that has Workers for Platforms and R2 enabled, plus a PostgreSQL database and a domain. Once running, admins control who can sign in and deploy, set resource limits, inspect deployments via dashboard or CLI, and enforce security policies. Non-technical teammates or coding agents can ship internal apps in minutes while remaining inside guardrails.

The Platform is fully open source. Organizations can fork it, integrate it with internal identity systems (Cloudflare Access, Google, GitHub, OIDC), or run it as a private deployment service for customers. Isolation is provided by Workers for Platforms; each app gets its own worker and resource bindings rather than sharing a single monolithic account.

## Technical Architecture and Differentiators

Void sits on top of the VoidZero toolchain (Vite+, Rolldown, Oxc) and Cloudflare’s runtime primitives:

- **Local-first development** — Bindings resolve locally; production provisioning happens only at deploy time.
- **Automatic resource inference** — Import `void/db` or `void/ai` and the CLI creates the corresponding D1 database, AI Gateway, queue, or KV namespace.
- **Type safety** — Schema-driven types flow from database queries through loaders/actions into UI components via `InferProps`.
- **Multi-target flexibility** — Primary target is Cloudflare Workers; Node/Bun/Deno targets exist for non-Cloudflare hosting.
- **Agent readiness** — CLI, MCP-style tooling, and generated agent instructions make Void suitable for automated workflows.

Compared with pure Wrangler + Cloudflare Vite plugin workflows, Void adds higher-level conventions (file-based routes, typed database layer, automatic provisioning) and the optional multi-tenant Platform layer. Compared with traditional PaaS offerings, it keeps the developer inside the familiar Vite ecosystem while giving operators fine-grained control over the underlying Cloudflare account.

## Getting Started and Practical Considerations

Requirements are modest: Node.js 24.21.0 or later. Quickstart:

```bash
npm install -D void
npx void init
npm run dev
npx void deploy
```

`void init` preserves existing package-manager lockfiles, installs Vite+ as the default toolchain, and lets you pick a UI framework and starter. Existing Vite projects can adopt Void by adding the plugin and running the same init flow.

**Edge cases and tips:**

- Complex meta-frameworks may need the Void plugin placed before the framework plugin in `vite.config.ts`.
- Cloudflare-specific features (certain bindings, Workers for Platforms isolation) are unavailable on non-Cloudflare targets.
- Platform self-hosting requires Workers for Platforms, R2, a PostgreSQL database, and a domain; review current docs for the exact install command.
- Coding agents benefit from the generated `AGENTS.md` and the CLI’s structured output; restrict platform permissions when agents are allowed to deploy.
- Because the project is young (public release October 2026), verify feature completeness against the live documentation at void.cloud for production use.

## Conclusion

Void represents a practical convergence of the Vite ecosystem and Cloudflare’s edge platform. By open-sourcing the SDK, CLI, and self-hosted Platform, Cloudflare and the VoidZero team give developers a zero-config path from Vite project to production Worker while giving operators a controllable multi-tenant layer that does not require handing out account-level credentials.

For teams already invested in Vite and looking to ship full-stack apps on Cloudflare—especially those exploring agent-driven development—the combination of typed database-to-UI flows, automatic resource provisioning, and one-command deploys is compelling. Start with `npx void init` on a personal account or evaluate the Platform for shared internal tooling.

Official resources: [void.cloud](https://void.cloud), [GitHub repository](https://github.com/voidzero-dev/void), and the Cloudflare blog announcement.