Libra AI

• Libra AI
  • 🚀 What is Libra AI?
    • ✨ Core Features
      • 🤖 AI-Powered Coding
      • 🛠️ Integrated Development Experience
      • 🔗 Full-Stack Integration
      • 🌐 Production Deployment
    • Why Open Source?
  • 🏗️ Technical Architecture
    • Compute & Runtime
    • Data Storage
    • Network & Security
    • Development Tools & Services
    • Application Services Overview
    • 🛠️ Core Technology Stack
      • Frontend Technology Architecture
      • Backend & API Architecture
      • AI & Machine Learning
      • Data Storage Architecture
      • Deployment & Infrastructure
      • Development Toolchain
  • ⚡ Quick Start
    • 🎯 Choose Your Usage Method
      • 🌐 Cloud Hosted Service (Recommended)
      • 💻 Local Development Deployment (Developers)
    • 📦 Environment Requirements
    • 🚀 Local Environment Setup
      • Step 1: Get Source Code
      • Step 2: Configure Environment Variables
      • Step 3: Initialize Database
      • Step 4: Start Development Services
      • Step 5: Configure Stripe Payment (Required)
    • 🌐 Local Service Addresses
  • 🚀 Deployment Options
    • 🌐 Cloud Hosted Service (Recommended)
    • 🏠 Self-Hosted Deployment
  • 🎯 Hosted Platform vs Open Source
    • 📊 Feature Comparison
    • 🤔 How to Choose the Right Version?
      • Choose Cloud Hosting if you
      • Choose Open Source if you
  • ❓ Frequently Asked Questions
    • 🆚 Product Versions
    • 🛠️ Technical Issues
    • 💼 Commercial Use
    • 🔧 Development & Deployment
    • 🤝 Community Contribution
      • 🌟 Usage & Promotion
      • 🔧 Code Contribution
      • 📝 Other Contribution Methods
      • 🎯 Contribution Guidelines
  • 📄 Open Source License
    • 📜 AGPL-3.0 Open Source License
      • ✅ Your Rights
      • 📋 Your Obligations
      • 💼 Commercial License
    • 💬 Participate in Roadmap Discussion
    • 🙏 Acknowledgments

---

🚀 What is Libra AI?

Libra AI is a production-ready AI-native development platform that enables full lifecycle management of web applications through natural language interaction. Built with modern technology architecture, it covers the complete engineering process from rapid prototyping to enterprise-grade production deployment.

Just as V0 is deeply integrated with the Vercel ecosystem, Libra is specifically designed for the Cloudflare Workers architecture, providing a native AI development experience.

✨ Core Features

🤖 AI-Powered Coding

• Multi-model integration: Claude, OpenAI, Gemini, DeepSeek, and more
• Natural language-driven production-grade code generation
• Intelligent context awareness and best practice adherence
• Multi-sandbox provider support (E2B, Daytona)

🛠️ Integrated Development Experience

• Cloud IDE: syntax highlighting, smart indentation, custom plugins
• Hot Module Replacement (HMR) real-time preview
• Intelligent dependency analysis and automatic installation

🔗 Full-Stack Integration

• Seamless GitHub integration with one-way sync
• Cloudflare edge computing deployment
• Enterprise-grade identity authentication (OAuth 2.0)
• Stripe commercial subscription management

🌐 Production Deployment

• Cloudflare Workers edge computing network
• Serverless architecture with elastic scaling
• Automated TLS/SSL certificate management
• Git version control with one-click rollback

Why Open Source?

• 📂 Technical Autonomy: Avoid vendor lock-in risks
• 🔧 Architectural Flexibility: Support for deep customization and extension
• 💝 Community Ecosystem: Open source community collaboration

🏗️ Technical Architecture

Libra is built entirely on Cloudflare. You need to be familiar with the following products:

Compute & Runtime

Data Storage

Network & Security

Development Tools & Services

Libra adopts Turborepo Monorepo architecture design:

libra/
├── apps/                    # Core application services
│   ├── auth-studio/         # Authentication management console (D1 + drizzle-kit)
│   ├── builder/             # Vite build service - code compilation and deployment
│   ├── cdn/                 # Hono CDN service - static asset management
│   ├── deploy/              # Deployment service V2 - Cloudflare Queues
│   ├── deploy-workflow/     # Deployment service V1 - Cloudflare Workflows (deprecated)
│   ├── dispatcher/          # Request routing dispatcher (Workers for Platforms)
│   ├── docs/                # Technical documentation site (Next.js + FumaDocs)
│   ├── email/               # Email service previewer (React Email)
│   ├── opennext-cache/      # OpenNext cache service (Cloudflare)
│   ├── screenshot/          # Screenshot service - Cloudflare Queues
│   ├── vite-shadcn-template/# Project template engine (Vite + shadcn/ui)
│   └── web/                 # Next.js 15 main application (React 19)
├── packages/                # Shared package modules
│   ├── api/                 # API layer (tRPC + type safety)
│   ├── auth/                # Authentication service (better-auth)
│   ├── better-auth-cloudflare/ # Cloudflare authentication adapter
│   ├── better-auth-stripe/  # Stripe payment integration
│   ├── common/              # Common utility library and type definitions
│   ├── db/                  # Main database schema and operations (PostgreSQL)
│   ├── email/               # Email service components
│   ├── middleware/          # Middleware services and tools
│   ├── sandbox/             # Unified sandbox abstraction layer (E2B + Daytona)
│   ├── shikicode/           # Code editor (Shiki syntax highlighting)
│   ├── templates/           # Project scaffolding templates
│   └── ui/                  # Design system (shadcn/ui + Tailwind CSS v4)
├── tooling/                 # Development tools and configuration
│   └── typescript-config/   # Shared TypeScript configuration
└── scripts/                 # GitHub environment variable management

Application Services Overview

🔒 Authentication Management Center (apps/auth-studio)

• User, organization, permission, and subscription lifecycle management
• Main database uses PostgreSQL (via Neon + Hyperdrive), authentication data uses D1 (SQLite)
• OAuth 2.0 multi-provider authentication system
• Stripe commercial payment gateway integration

🔨 Build Compilation Service (apps/builder)

• Vite high-performance build engine with millisecond-level hot startup
• Automatic code compilation and seamless production deployment
• Multi-tech-stack project template rapid instantiation

📺 Content Distribution Service (apps/cdn)

• Hono framework-driven file management system
• Intelligent image processing and compression optimization
• Global CDN edge caching acceleration
• Cloudflare Workers edge deployment

🚀 Deployment Service V2 (apps/deploy)

• Modern deployment architecture based on Cloudflare Queues
• Batch processing and concurrency control
• D1 database state management
• Dead letter queue handling for failed deployments
• Comprehensive error handling and retry logic

⚡ Deployment Service V1 (apps/deploy-workflow, deprecated)

• Deployment orchestration based on Cloudflare Workflows
• Step-by-step deployment process and state management
• Built-in retry mechanism and error recovery
• Support for complex deployment scenarios and dependency management

🔀 Request Routing Service (apps/dispatcher)

• Workers for Platforms core routing component
• Route user domain requests to corresponding Worker instances
• Dynamic Worker scheduling and lifecycle management
• Custom domain binding and SSL certificate handling
• Unified authentication and access control layer
• Cloudflare SaaS for Platforms integration

📖 Technical Documentation Site (apps/docs)

• FumaDocs modern documentation solution
• Cloudflare Workers global distribution

📧 Email Notification Service (apps/email)

• React Email component-based email development
• Multi-scenario email template engine

🔄 OpenNext Cache Service (apps/opennext-cache)

• Next.js Cloudflare deployment cache optimization
• OpenNext framework and Cloudflare Workers integration
• Seamless integration with main web application deployment

📸 Screenshot Service (apps/screenshot)

• Cloudflare Queues-based screenshot generation
• Asynchronous queue processing for web screenshot requests
• Automated website preview image generation
• R2 storage for screenshot files
• Batch processing and error retry

🔨 Project Scaffolding Service (apps/vite-shadcn-template)

• Vite high-performance build toolchain
• Fast compilation and production deployment
• Pre-configured shadcn/ui + Tailwind CSS v4
• Visual template selection and preview

🌐 Core Web Application (apps/web)

• Next.js 15 App Router + React 19 technology stack
• Platform main interface and user interaction layer
• AI-driven intelligent conversation and project management
• Real-time code editing, preview, deployment, and version control
• Cloudflare Workers serverless deployment

🛠️ Core Technology Stack

Frontend Technology Architecture

Backend & API Architecture

AI & Machine Learning

Data Storage Architecture

Deployment & Infrastructure

Development Toolchain

⚡ Quick Start

🎯 Choose Your Usage Method

🌐 Cloud Hosted Service (Recommended)

• Visit libra.dev to get started
• Quick registration with GitHub OAuth or email
• Build production-grade applications in minutes

💻 Local Development Deployment (Developers)

• Complete source code access and control
• Deep customization development and extension
• Private/enterprise-grade deployment

📦 Environment Requirements

# System dependency requirements
git --version   # >= 2.30.0
node --version  # >= 20.0.0 (recommend 24)
bun --version   # >= 1.0.0

🚀 Local Environment Setup

Step 1: Get Source Code

git clone https://github.com/nextify-limited/libra.git
cd libra
bun install
# (Optional) Generate i18n files for apps/web
cd apps/web && bun run prebuild && cd ../..

Step 2: Configure Environment Variables

cp .env.example .env

Edit the .env file to configure necessary environment variables.

Step 3: Initialize Database

Main database (PostgreSQL) initialization:

# Generate and run migrations from project root
cd packages/db
bun db:generate
bun db:migrate

Authentication database (D1/SQLite) initialization:

# Test D1 database connection (local environment)
cd apps/web && bun wrangler d1 execute libra --local --command='SELECT 1'

# Generate and run authentication database migrations
cd packages/auth
bun db:generate
bun db:migrate

Step 4: Start Development Services

# Start all services
bun dev

# Or start main application separately
cd apps/web && bun dev

Step 5: Configure Stripe Payment (Required)

Configure corresponding products:

stripe listen --forward-to localhost:3000/api/auth/stripe/webhook

🌐 Local Service Addresses

After setup, you can access various services through the following addresses:

• Core Application (web): http://localhost:3000
• Email Preview (email): http://localhost:3001
• Authentication Management (auth-studio): http://localhost:3002
• Technical Documentation (docs): http://localhost:3003
• CDN Service (cdn): http://localhost:3004
• Build Service (builder): http://localhost:5173 (Vite default port)
• Template Service (vite-shadcn-template): http://localhost:5173 (Vite default port, may conflict with builder)
• Routing Service (dispatcher): http://localhost:3007
• Deployment Service V2 (deploy): http://localhost:3008
• Screenshot Service (screenshot): http://localhost:3009
• Deployment Service V1 (deploy-workflow, deprecated): http://localhost:3008 (shares port with Deployment Service V2)

🚀 Deployment Options

🌐 Cloud Hosted Service (Recommended)

Ready-to-use cloud development experience:

1. Visit libra.dev official platform
2. Quick registration with GitHub OAuth or email
3. AI-driven rapid application building
4. One-click deployment to custom domains

Cloud Service Advantages:

• Zero-configuration out-of-the-box
• Elastic scaling and automatic updates
• Built-in AI model integration
• Enterprise-grade technical support

🏠 Self-Hosted Deployment

1. Deploy Libra Platform Itself

All Libra platform services are deployed on Cloudflare Workers:

# Deploy various services to Cloudflare Workers
# Refer to the following workflow files for complete deployment process:
# - .github/workflows/web.yml - Main application deployment
# - .github/workflows/cdn.yml - CDN service deployment
# - .github/workflows/deploy.yml - Deployment service deployment
# - .github/workflows/dispatcher.yml - Routing service deployment
# - .github/workflows/screenshot.yml - Screenshot service deployment
# - .github/workflows/docs.yml - Documentation site deployment

2. Deploy User Projects as PaaS Platform

Libra uses Workers for Platforms technology to provide project deployment capabilities for users, offering two deployment service architectures:

1. Workers for Platforms Architecture:

   • Each user project is deployed as an independent Worker
   • Intelligent routing through dispatcher service
   • Support for custom domain binding
   • Completely isolated runtime environment (process-level isolation through Workers for Platforms)

2. Deployment Service Architecture Options:

   V2 Queue Architecture (apps/deploy):

   • Cloudflare Queues: Asynchronous queue processing for deployment tasks
   • Batch Processing: Support for concurrency control and batch deployment
   • Dead Letter Queue: Retry mechanism for handling failed deployments
   • Use Cases: High concurrency, large-scale deployment needs

   V1 Workflow Architecture (apps/deploy-workflow, deprecated):

   • Cloudflare Workflows: Step-by-step deployment orchestration
   • State Persistence: Built-in state management and recovery mechanism
   • Complex Processes: Support for complex deployment dependencies and conditional logic
   • Use Cases: Complex deployment processes, scenarios requiring precise control

3. General Deployment Process:

   • Verify user permissions and project quotas
   • Create sandbox environment for secure building (supports E2B or Daytona)
   • Sync project files
   • Execute build commands (bun install & bun build)
   • Deploy to user's Worker instance using Wrangler API
   • Update routing configuration, clean up temporary environment

4. Technical Features:

   • Sandbox Environment: Secure isolated build environment (supports E2B or Daytona)
   • Global Distribution: Leverage Cloudflare edge computing network
   • Flexible Architecture: Choose appropriate deployment service based on needs

🎯 Hosted Platform vs Open Source

📊 Feature Comparison

🤔 How to Choose the Right Version?

Choose Cloud Hosting if you

• 🚀 Quick Launch: No complex configuration needed, start application development immediately
• 💼 Business Priority: Focus on product development rather than infrastructure operations
• 👥 Team Collaboration: Need enterprise-grade team management features
• 📞 Professional Service: Expect official technical support and SLA guarantees
• 🔄 Automatic Operations: Want platform automated updates and maintenance

Choose Open Source if you

• 🏠 Data Autonomy: Complete control over data storage and processing
• 🔧 Deep Customization: Need to modify core functionality or integrate proprietary business logic
• 💰 Cost Control: Have technical team, need to optimize long-term operational costs
• 🌍 Special Deployment: Specific region/private network/offline environment deployment
• 📚 Technical Learning: Deep understanding of complete technical architecture design

❓ Frequently Asked Questions

🆚 Product Versions

Q: What are the core differences between the hosted platform and open source version?

A: Cloud hosting is an official SaaS service, ready to use upon registration, including complete AI capabilities and enterprise-grade features. Open source version provides core source code, supports self-deployment and deep customization, but requires self-configuration of AI APIs and operational environment.

Q: How complete are the features in the open source version?

A: The open source version includes the platform's core functional architecture. We follow the principle of "99% features open source, 1% commercial services" to ensure developers can access complete technical capabilities.

🛠️ Technical Issues

Q: What technical background is required to use Libra?

A: Depends on usage method:

• Hosted platform users: No technical background required, just need to use a browser
• Local developers: Need basic web development knowledge and Node.js experience
• Self-hosted deployment: Need server and DevOps practical experience

Q: How is the quality of AI-generated code?

A: We always pursue production-grade code quality:

• Complete TypeScript type safety guarantee
• Follow modern React development patterns and industry best practices
• Responsive design implementation based on Tailwind CSS
• Accessible components integrated with Radix UI
• Clear and maintainable code structure and comments

Q: Can I customize AI behavior and prompts?

A: Full customization is supported in the open source version:

• Custom AI prompt engineering
• Flexible model selection logic configuration
• Modify code generation templates
• Integrate third-party AI services

💼 Commercial Use

Q: Can Libra be used for commercial projects?

A: Absolutely. We provide multiple commercial solutions:

• Hosted platform: Business-friendly pay-as-you-go model
• Open source version: Follows AGPL-3.0 open source license, requires derivative projects to also be open source
• Commercial licensing: Provides commercial open source licenses for enterprises requiring closed-source deployment

Q: How about data security and privacy protection?

A: We provide different levels of data protection solutions:

• Hosted platform: Data processed in our secure infrastructure, compliant with international security standards
• Self-hosted deployment: You have complete control over data storage, processing, and access permissions
• Enterprise customization: Can provide customized solutions based on special security requirements and compliance needs

Q: Do you provide enterprise-grade technical support?

A: Yes. Our enterprise services include:

• Private cloud environment deployment
• Custom feature development services
• Dedicated technical support team
• Service Level Agreement (SLA) guarantees
• Security auditing and compliance support

For enterprise services, please contact: [email protected]

🔧 Development & Deployment

Q: Which deployment platforms are supported?

A: Currently only supports deployment on Cloudflare

Q: How to participate in open source project contributions?

A: We warmly welcome community contributions. For specific methods, please refer to the Community Contribution Guidelines below.

🤝 Community Contribution

We warmly welcome contributions from developers worldwide! Here are the ways you can participate:

🌟 Usage & Promotion

• Experience Libra platform and share your usage experience
• Create amazing application projects and showcase them in the community
• Write technical blog articles or create tutorial videos
• Share and recommend Libra on social media platforms

🔧 Code Contribution

# 1. Fork our repository on GitHub
# 2. Clone your fork to local
git clone https://github.com/your-username/libra.git
cd libra

# 3. Create feature development branch
git checkout -b feature/your-amazing-feature

# 4. Develop and test thoroughly
bun install
bun dev

# 5. Commit code with clear commit messages
git commit -m "feat: add incredible new feature"

# 6. Push branch and create Pull Request
git push origin feature/your-amazing-feature

📝 Other Contribution Methods

• Documentation Improvement: Improve usage guides, add example code, fix documentation errors
• Issue Reporting: Help us discover and locate system issues
• Feature Suggestions: Propose improvement ideas and new feature requirements
• Multi-language Support: Help translate Libra into more languages
  • Project uses Paraglide.js for internationalization
  • Translation file location: apps/web/messages/[locale].json
  • Add new language: Add language code in apps/web/project.inlang/settings.json
• Community Support: Help other users in forum and GitHub discussions

🎯 Contribution Guidelines

• Please follow our Code of Conduct
• Read and follow Contribution Guidelines
• Use standardized commit message format (Conventional Commits)
• Provide corresponding test cases for new features
• Update relevant documentation in a timely manner

📄 Open Source License

📜 AGPL-3.0 Open Source License

Libra is released under the GNU Affero General Public License v3.0 open source license.

✅ Your Rights

• 🆓 Free Use: Free to use for personal, educational, and commercial projects
• 🔧 Modification and Customization: Free to modify and extend code functionality
• 📤 Distribution and Sharing: Can share with others under the same license
• 🏢 Commercial Deployment: Allowed for commercial purpose deployment

📋 Your Obligations

• 📄 Retain Copyright Information: Must retain original copyright notices
• 🔓 Open Source Derivative Works: Must provide source code for any modifications
• 📧 Network Service Open Source: Must open source when providing services over network
• 🔗 Use Same License: Derivative works must use AGPL-3.0 license

💼 Commercial License

If you need more flexibility, we provide commercial licenses suitable for:

• Closed-source proprietary modifications
• Product distribution without open sourcing
• Customized licensing terms

Commercial licensing consultation: [email protected]

💬 Participate in Roadmap Discussion

We welcome community participation in roadmap planning:

• 📝 Feature Requests
• 💬 Roadmap Discussion
• 📧 Enterprise Requirements

🙏 Acknowledgments

Thanks to the following excellent sponsors for their valuable support to the Libra project, enabling us to focus on building better AI development experiences for developers:

Clerk - The most comprehensive user management platform

E2B - E2B is an open-source runtime environment for executing AI-generated code in secure cloud sandboxes, suitable for intelligent agents and AI application scenarios.

PostHog - A single platform for analytics, testing, observing, and deploying new features

Daytona - Daytona is a secure and resilient infrastructure for running AI-generated code

Cloudflare - Global leading edge computing and network infrastructure provider

---