Vanilla Cookbook

Vanilla Cookbook is a self‑hosted recipe manager that prioritizes developer flexibility while keeping the end‑user interface minimal. Built with SvelteKit, it leverages server‑side rendering and client‑side hydration to deliver a fast, SPA‑like experience without the bloat of heavier frameworks. The core engine parses raw recipe text—no enforced schema—using a lightweight, rule‑based parser that supports multiple languages and ingredient formats. This design choice removes the need for complex migrations or data‑entry workflows, allowing developers to focus on extending functionality rather than wrestling with data normalization.

Technical Stack & Architecture

• Frontend: SvelteKit (TypeScript‑enabled) with Tailwind CSS for rapid styling and a PWA manifest that enables mobile installation. The client communicates over RESTful JSON endpoints, while optional GraphQL support can be added via a plugin.
• Backend: A Node.js server powered by Express‑style routing inside SvelteKit’s hooks. All business logic—parsing, unit conversion, recipe scaling—is encapsulated in pure JavaScript modules that can be imported into custom plugins.
• Database: A lightweight, file‑based SQLite3 database is used by default for simplicity. For production workloads, the ORM layer (knex.js) can be swapped to PostgreSQL or MySQL without code changes, thanks to its query‑builder abstraction.
• Deployment: Docker Compose is the primary distribution method, but a pure npm run dev mode is available for quick prototyping. The container exposes port 3000 and mounts a volume for persistence, making scaling to Kubernetes trivial with a simple StatefulSet.

Core Capabilities & APIs

• Ingredient Parsing: A public API endpoint (/api/parse) accepts raw text and returns a structured JSON representation of ingredients, units, and quantities. It supports 10+ languages and can be extended via a plugin hook that injects custom regex patterns.
• Unit & Recipe Scaling: /api/scale takes a recipe ID and a multiplier, returning updated ingredient quantities. Internally it uses the convert-units library for accurate conversions across US, metric, and imperial systems.
• Scraping & AI Assist: Two endpoints (/api/scrape and /api/ai-parse) allow developers to integrate third‑party scraping services or LLMs (OpenAI, Anthropic). The AI endpoint accepts an image or plain text and returns a parsed recipe object, making it straightforward to build custom ingestion pipelines.
• Webhooks & Extensions: The platform emits JSON webhooks on recipe creation, update, and deletion. A plugin system exposes hooks such as onRecipeSave and onIngredientParse, enabling developers to inject analytics, sync with external services, or modify data before persistence.

Deployment & Infrastructure

Vanilla Cookbook is intentionally lightweight: a single Docker image (~200 MB) runs on any Linux host, and the Node.js runtime is fully compatible with Cloudflare Workers or Vercel Serverless functions if developers prefer a serverless model. The SQLite database can be swapped for PostgreSQL by editing the knexfile.js, and the migration scripts are idempotent, ensuring zero downtime during upgrades. Horizontal scaling is achievable by clustering the Node process (via PM2 or Docker Swarm) and sharing a network‑mounted database or using a read‑replica setup for heavy read workloads.

Integration & Extensibility

The application exposes a RESTful API that is fully documented in OpenAPI format, making it trivial to generate SDKs for any language. Developers can build custom front‑ends (React, Vue, Angular) that consume these endpoints or extend the existing SvelteKit UI with new routes. The plugin architecture uses a simple JSON manifest (plugin.json) and an index.js entry point, allowing third‑party modules to register new routes, middleware, or database migrations. Community plugins already exist for syncing with Google Sheets, exporting to PDF, and integrating with kitchen appliances via MQTT.

Developer Experience

The codebase follows strict linting (ESLint + Prettier) and TypeScript type safety, reducing runtime errors. The documentation is hosted on ReadTheDocs and includes detailed API references, migration guides, and a developer onboarding checklist. The active GitHub community provides quick issue resolution, feature requests, and pull‑request reviews. Licensing is permissive (MIT), ensuring that proprietary extensions or commercial deployments impose no restrictions.

Use Cases

• Personal Kitchen Automation: A hobbyist can run Vanilla Cookbook on a Raspberry Pi, expose it via Traefik, and integrate with smart fridges to auto‑populate shopping lists.
• Corporate Recipe Management: A catering business can deploy the app on an internal Kubernetes cluster, expose a public API to their front‑end web app, and use the webhook system to sync recipes with inventory software.
• Educational Platforms: A culinary school can host the app on a university server, use the plugin system to add grading metrics, and provide students with PWA access on campus tablets.

Advantages Over Alternatives

Vanilla Cookbook offers uncomplicated data ingestion (no rigid schemas), a lightweight, modern tech stack that keeps resource usage low, and an extensible API surface that lets developers build custom integrations without touching the core code. Its permissive license and active community mean you can adapt it to niche workflows—such as multilingual recipe parsing or AI‑dr