Deploy with Void

Introducing Void: an open-source SDK, CLI, and self-hosted platform for building full-stack Vite apps and deploying them to Cloudflare.

CN

Christoph NakazawaCloudflare

·October 15, 2026·JavaScript

What Void adds to the Vite toolchain

VoidZero's Vite, Vitest, Oxc and Rolldown — packaged together as Vite+ — cover development, bundling, code quality and testing. Full-stack work needs more: server routes, a database, a local environment, and a short path to production. Three newly open-sourced products close that gap and fold server routing, typed data access and Cloudflare deployment into a single Vite workflow:

Void Platform: a shared deployment platform for hosting Void apps on Cloudflare.
Void SDK: a composable JavaScript SDK for full-stack Vite apps.
Void CLI: a CLI that provisions resources and deploys Vite apps to Cloudflare.

Apps built with the SDK are deployed to the Platform by the CLI. Everything ships as one JavaScript package and Vite plugin, installed with npm install void. The result: server and client built together, types carried from database to UI, and Cloudflare resources provisioned automatically.

The original plan was a single private platform for all users. After VoidZero joined Cloudflare, the team open-sourced it and let anyone install it instead, pointing at a specific need: companies want to encourage vibe-coded internal apps, but are concerned about security and do not want to give cloud access to every employee.

Platform

The Platform is fully open source. A fork can integrate company systems, change deployment workflows, add customer-facing features, or target other deployment platforms; the upstream code can equally be used as-is or as a starting point with improvements contributed back.

Admins control access, set resource limits, inspect deployments and usage through the CLI or admin dashboard, and lay down guardrails so everyone else can ship serious and vibe-coded apps to the same shared platform.

A Platform install gives a team or its customers a shared deployment environment inside their own Cloudflare account, running on Workers for Platforms. Reuse typically falls into two patterns:

Faster prototyping. Build a prototype, deploy it, and share the working app for feedback without a separate Cloudflare account or per-project resource provisioning — cutting time to ship internal apps from days or weeks to minutes.
Non-technical teams building. Teammates who normally don't write code can work with coding agents to build and share their own apps under the same security measures — a designer's interactive prototype, an operations teammate's internal dashboard.

Self-hosting requires a Cloudflare account with Workers for Platforms and R2 enabled, a PostgreSQL database, an account with a chosen login provider, and a domain for the apps. Platform installation is one command; once it's up, approved users connect through the Void CLI to deploy.

void connect https://api.orange-company.dev

On the app side, the SDK powers Platform features such as authentication, framework detection and resource provisioning — the Platform only works because the SDK and CLI ship alongside it.

SDK

Void turns a Vite app into a full-stack Cloudflare Workers app. Code written by a developer or an agent is enough: Void infers resource bindings and provisions databases, queues or AI bindings during deployment. Setup is a Vite plugin:

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

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

Adapters ship for popular JavaScript UI frameworks including React and Vue, along with file-based API routing, pre-rendering, caching, islands, and end-to-end type safety from the database to the UI. Every feature is optional and composable.

Existing application frameworks can stay in place — Vinext, React Router, SvelteKit, Nuxt, TanStack Start, Astro — handling routing and rendering while Void supplies resource APIs via Hono, migrations, deployment and authentication via Better Auth. A server-rendered page with types flowing from a database query to the client looks like this:

// 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>;

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

Importing void/db gives the app a local database during development, and makes void deploy provision D1 in production automatically. The same pattern applies to Cloudflare's AI Gateway through void/ai.

// routes/api/decide.ts
import { defineHandler } from 'void';
import { ai } from 'void/ai';

export const POST = defineHandler(async (c) => {
  const { question } = await c.req.json();
  const result = await ai.run('@cf/cloudflare/clef', {
    model: 'clef',
    state: {},
    questions: {
      decision: { type: 'noul', instructions: question },
    },
  });
  const probability = result.answers.decision.noul;
  return c.json({
    answer: probability >= 0.5 ? 'yes' : 'no',
    probability,
  });
});

The React router targets Async React, using transitions and Suspense for responsive navigation. Combined with a modern data framework such as fate and UI libraries such as Astryx, navigation, data fetching and mutations can be coordinated through React transitions, actions and optimistic updates across the whole application: apps feel synchronous on fast networks, degrade gracefully on slower ones, and stay responsive during expensive rendering updates.

Teams that don't need Platform team-management features can deploy to their own Cloudflare account — the SDK deploys to Cloudflare directly.

CLI

The CLI is the main interface to Void and handles both platform management and app deployment. It is built on the new cf CLI and works well with agents, which can debug failing requests, read deployment logs, analyze app performance, or take a finished app through deployment end to end.

Deployment is void deploy. On first run the CLI prompts for a Cloudflare login; Void then builds the app with Vite, applies migrations, provisions resources automatically, and deploys to Cloudflare or a Void Platform. The same CLI covers the project lifecycle, and because an agent drives it as readily as a person does, it also manages a Platform: