Open navigation
a framework forproduct-integrated apps
Bring the stack you already use. Farm.js connects your app router, typed APIs, middleware, integrations, docs, and deployment so they work together as one product.
Farm.js is the framework for modern product-integrated apps. Build this as a production-ready Farm.js product app.
Before editing:
1. Read the Farm.js site skill at https://farmjs.dev/skill.md and the agent working rules at https://farmjs.dev/AGENTS.md.
2. Use https://farmjs.dev/llms.txt as the compact framework map. Start with https://farmjs.dev/docs/getting-started.md, https://farmjs.dev/docs/project-structure.md, and https://farmjs.dev/docs/reference.md, then fetch the smallest task-specific pages linked from the map.
3. Inspect package.json, farm.config.*, src/app, and existing project patterns. Match the installed @farm.js/* versions and verify every import against the current docs. Never invent an export.
Farm.js evolves quickly and may not be represented accurately in your training data, so treat the current docs and installed packages as the source of truth. Do not guess APIs or substitute Next.js or TanStack conventions.
Use Farm's documented App Router, typed APIs and server functions, middleware, Cron, integrations, environment boundaries, data loading and cache, and deployment APIs. If the docs are missing or conflict with the project, report the gap instead of silently improvising with another framework's behavior.
Preserve existing conventions, validate untrusted input, keep secrets server-only, add focused tests, and run typecheck, tests, and a production build before finishing.
A blazingly fast dev server
Start the whole app once, then see every page request and response time as you work.
$ pnpm devFarm.js v0.1.0-beta.22 ready in 23ms➜ Local:http://localhost:3000/➜ Network:http://192.168.1.24:3000/[FARM] [PAGE] [GET] /contact - 200 (8ms)[FARM] [API] [POST] /api/waitlist - 200 (5ms)[FARM] [PAGE] [GET] /docs - 200 (11ms)Types from route to client
Define an API route once. Farm.js generates a client with typed inputs and responses.
const { data, error } = await api.users.get({ query: { limit: "5" },});if (error) throw error;data?.users[0]?.name;// ^? string | undefinedConnect once. Keep full control.
Connect billing, API keys, and more in one place. Pass existing provider instances and call every service through typed APIs.
import Stripe from "stripe";import { stripe } from "@farm.js/integrations/stripe";import { unkey } from "@farm.js/integrations/unkey";const stripeClient = new Stripe(process.env.STRIPE_SECRET_KEY!);export const integrations = { billing: stripe({ instance: stripeClient }), keys: unkey({ rootKey: process.env.UNKEY_ROOT_KEY, apiId: process.env.UNKEY_API_ID, }),};Build once. Deploy together.
Farm.js packages routes, middleware, typed clients, and deployment config into one production build.
$ farm build --preset node-server[info] 🚜 Building Farm.js application with preset: node-server...[info] 🔍 Discovering routes and API endpoints...[info] 📦 Building client and SSR bundles in parallel...[bench] Fixture build wall time 527ms median[info] 📁 Output directory: .farm/.outputFramework benchmarks
Farm gets your first page running: 5.47× faster than Next.js; 3.17× faster than SvelteKit; 9.21× faster than Nuxt; 3.17× faster than TanStack Start.
Cold dev startup through the first rendered SSR page, measured against the same routed fixture.
Farm builds the same fixture: 4.53× faster than Next.js; 3.19× faster than SvelteKit; 8.47× faster than Nuxt; 1.25× faster than TanStack Start.
A complete production compile of the same SSR project, with generated output ready to boot.
Farm.js leads the benchmark app across latency and output size. Raw medians for startup, build, boot, SSR, and HTML.
Dev start
Warm dev
Build
Prod boot
SSR p50
HTML
Bring the tools you already use
Start with built-in Farm Auth, keep full control with Better Auth, then add integrations for billing, email, jobs, KV storage, agents, API keys, and UI—or connect your own.
The app router you know
Build pages, layouts, API routes, loading states, and typed links in one app directory.
Deploy where you want
Ship to Vercel, Cloudflare, Netlify, or self-hosted Node with built-in Nitro presets.
Docs for people and agents
Enable a complete docs surface with MDX, navigation, search, MCP, and agent-ready endpoints from the same source.
import { defineConfig } from "@farm.js/core";export default defineConfig({ docs: { enabled: true, entry: "/docs", search: true, mcp: true, },});Share architecture, not boilerplate
Compose routes, middleware, integrations, components, and config from local or package layers. Project files always win.
import { defineConfig } from "@farm.js/core";export default defineConfig({ routeRules: { "/products/**": { swr: 300 }, },});Key/value storage for the runtime
Mount SQLite, Redis, S3, or another key/value driver for caches, settings, counters, idempotency records, and object-backed values.
export default defineConfig({ storage: { mounts: { app: sqliteStorage({ path: "./data.sqlite" }), cache: redisStorage({ url: process.env.REDIS_URL! }), }, },});Configure the whole route in one place
Validate params, prepare request data, load the page, and run post-load work in one typed route definition.
export const ProductRoute = createRoute("/products/[id]", { params: ProductParams, data: { before: () => auth.user({ required: true }), main: ({ params, before }) => getProduct(params.id, before.id), after: ({ data }) => recordView(data.id), }, pending: ProductSkeleton, error: ProductError, component: ProductPage,});Native rendering for static regions
Farm detects large, host-only Server Component regions and renders eligible trees through Strata's Rust-native renderer. Everything else stays on React.
Every page, readable by agents
Every app page receives a Markdown representation at a .md URL or through content negotiation. Keep the generated output or override it with page.md.
Bring the agent runtime you already use
Run Eve on Vercel or Cloudflare Agents on Workers. Farm joins each runtime to your app in development and production while its native SDK stays intact.
//eve/*Vercel/agents/*WorkersRun agents beside the app
Choose Eve or Cloudflare Agents. Farm starts the runtime in development, owns its same-origin routes, and composes supported production output.
import { eve } from "@farm.js/eve";export default defineConfig({ integrations: { agent: eve(), }, deploy: { target: "vercel", },});Keep the provider-native SDK
Use useEveAgent for durable conversations or useAgent for typed WebSocket state and RPC. Farm does not add a duplicate client layer.
"use client";import { useEveAgent } from "eve/react";export function useChat() { const agent = useEveAgent(); return { messages: agent.data.messages, send: agent.send, };}One framework. The whole product.
Build routing, APIs, integrations, agents, docs, and deployment together in one React framework.