Gingee - Application Server

A Gen AI Project

See AI Disclaimer

The objective of the project is to validate the feasibility of GenAI in platform/framework level programming as opposed to generating simplistic applications and in the process be the world's first AI authored and human co-authored production ready application server. To ensure full transparency, a key part of the development has been the meticulous recording of the chat transcript. You can find the link to the transcript below

Chat Transcript - Click here to see the full AI chat transcript from start of this project till date|

What is Gingee?

Gingee is a secure, batteries-included Node.js application server designed to dramatically accelerate web app development. Co-authored by a human architect and a GenAI partner, it provides a full featured platform that allows developers to focus on business logic instead of boilerplate. It achieves this through a secure sandbox, a powerful module ecosystem, and a comprehensive application lifecycle management system.

🚀 Quick Start

Get a new, fully configured Gingee server running in under a minute. See video

# 1. Install the Gingee CLI (may take a few moments to complete)
npm install -g gingee-cli

# 2. Create a new Gingee project
gingee-cli init my-gingee-project

# 3. Navigate into your new project
cd my-gingee-project

# 4. Start the server!
npm start

# 5. Browse to http://localhost:7070

That's it! You should now see Glade - the Gingee admin panel in your web browser. You can install applications for the Gingee platform from the Gingee App Store.

Key Features

Gingee is a comprehensive platform designed to provide a secure, efficient, and enjoyable development experience.

• Secure by Default

  • Whitelist Permissions System: Applications have no access to the filesystem, database, network, email, generative AI, or CRON scheduler by default. Administrators grant explicit permissions for a "secure by default" posture. See the Threat Model (cooperative multi-app vs hostile multi-tenant).
  • Sandboxed Execution: Every server script runs in a gbox vm sandbox: restricted require, path jails, no host process (cooperative isolation on a shared process—not a hard multi-tenant VM boundary). String eval/Function allowed by default for common UMD libs; optional lockdown via box.allow_code_generation: false.

• Instant Time to Joy

  • All-in-One CLI: A single command (gingee-cli init) scaffolds a complete, runnable project with a built-in admin panel.
  • Simplified API: All request/response logic is handled through a single, powerful context object ($g) provided by the gingee() middleware.
  • Flexible Routing: Use zero-configuration file-based routing for rapid development, or create a routes.json for powerful, dynamic RESTful APIs.
  • Modern JavaScript: Use modern ESM syntax (import/from) directly in your server scripts with zero build steps or configuration.

• Batteries-Included Backend

  • Multi App Hosting: Deploy and run multiple apps with clear isolation, individual app lifecycles and hot app reloads.
  • Multi-Database Support: Write your code once and deploy against PostgreSQL, SQLite, MySQL, and more, with a consistent API.
  • Rich Standard Library: A comprehensive suite of sandboxed modules for common tasks, including crypto, image processing, pdf generation, db access, httpclient, transactional email, and generative ai (streaming chat, multimodal, document parse, moderation).
  • Streamed Responses: Progressive output (e.g. SSE) via $g.response.startStream / writeSSE / endStream.
  • CRON Scheduler: Declarative app.json schedules (script/url/queue); scheduler.enabled (default off); optional Redis multi-node coordination; Glade Schedules / Run now.
  • Request limits & egress: Concurrency/timeouts (limits) and default-protected SSRF policy (egress) for outbound HTTP.
  • Config secrets: env: / file: references resolved at load; sandbox has no host process.
  • Metrics & audit: Prometheus /metrics (localhost-only by default) and JSONL audit for permissions/lifecycle.
  • Process isolation (opt-in): Child-process script workers via isolation config; same public HTTP port; Glade stays in-process; buffered + SSE (incl. AI), solo apps or groups, auto-restart, worker ai/email re-init, worker_limits.
  • WebSockets (opt-in): Master-owned ws upgrade per app; rooms/broadcast via require('websockets'); optional Redis fan-out for multi-node rooms; sample ginchat.
  • Background queue: require('queue') memory/redis, retries, DLQ, box/jobs/; Glade live jobs + DLQ admin.
  • Optional feature packages: sharp (image), non-SQLite SQL drivers, chart/canvas, pdfmake, SendGrid, and Gemini SDK are optionalDependencies (slim via npm install --omit=optional).
  • Application Startup Hooks: Define startup_scripts to automatically run database migrations or seed data when your app is installed or upgraded.
  • Application Middleware: Define default_include to automatically inject scripts in front of all API end points of the app. Enabling easy authentication, policies, role management etc.

• Full Lifecycle & Automation

  • Glade Admin UI: App lifecycle (install, upgrade, rollback, delete, permissions), Schedules / Run now, and Queue / DLQ (live jobs + dead letter).
  • Interactive Installers: Both the CLI and the Glade UI feature intelligent installers that read an app's requirements, prompt the admin for permission consent, and guide them through database configuration.
  • Automated Deployments: All lifecycle commands in the CLI can be run non-interactively using a preset file, making it perfect for CI/CD pipelines.
  • Automatic Maintenance Mode: The server automatically puts an application into a 503 Service Unavailable state during critical lifecycle events to ensure data integrity.
  • Built for Scale: With a pluggable distributed caching system (Redis), native service installation, and PM2 compatibility.

• Decentralized App Store

  • Discover and install applications from any gstore.json manifest on the web using the gingee-cli. Anyone can host their own public or private app store.

• GenAI-Native Workflow

  • Co-authored by a human architect and a Generative AI partner, Gingee is a testament to a new, highly efficient "Dialog-Driven Development" workflow. The project includes a pre-built knowledge bundle (ai-context.md) to empower you to build your own apps with an AI partner.

Documentation

Dive deeper into the architecture and learn how to build powerful applications with Gingee.

Concepts

Configuration & Setup

Developer Docs

Refrence

Project Details

Tooling

Google AI Studio, VS Code, NodeJS, NPM, JSDoc

Contributing

Please see our CONTRIBUTING guide for more details on how to contribute.

License

Gingee is licensed under the MIT License. See the LICENSE file for details.

Credits