GitWit is an open-source cloud-based code editing environment with custom AI code generation, live preview, and AI chat.

For the latest updates, join our Discord server: discord.gitwit.dev.

A quick overview of the tech before we start: This is a Turborepo monorepo with a Next.js app for the frontend (with Hono API routes), and an Express server on the backend for WebSocket/real-time connections.

Required accounts to get started:

• Clerk: Used for user authentication.
• E2B: Used for the terminals and live preview.

AI Provider Options:

GitWit supports multiple AI providers. You can either:

• Use system-level API keys (set in .env - recommended for development)
• Let users configure their own API keys via Dashboard Settings (recommended for production)

Supported providers:

• Anthropic: Claude models for code generation and chat
• OpenAI: GPT models for code generation and chat
• OpenRouter: Access to multiple AI models through a single API
• AWS Bedrock: Claude models via AWS infrastructure

No surprise in the first step:

git clone https://github.com/jamesmurdza/gitwit
cd gitwit

Copy .env files:

cp .env.example .env
cp web/.env.example web/.env
cp server/.env.example server/.env

Install dependencies:

npm install

Install and start Postgres:

brew install postgresql
brew services start postgresql

Create a database:

psql postgres -c "CREATE DATABASE gitwit;"
# psql postgres -U  postgres -c "CREATE DATABASE gitwit;"  # Use this if the above fails

Initialize the database schema (run from project directory):

npm run db:generate
npm run db:migrate

After making any changes to your database schema, run these commands again to update your local database. The migration files created are not committed to version control.

DATABASE_URL=

npm run db:generate:prod
npm run db:migrate:prod

Get API keys for E2B and Clerk (required), plus at least one AI provider (optional for system-level access).

Add them to the .env file along with the database connection string.

Required:

DATABASE_URL='🔑'
E2B_API_KEY='🔑'
CLERK_SECRET_KEY='🔑'
NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY='🔑'

Optional (Custom API Keys Feature):

ENCRYPTION_KEY='🔑'  # 32-byte hex string for encrypting user API keys

To enable the custom API keys feature (allowing users to configure their own API keys), set ENCRYPTION_KEY. Generate one using:

node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
# or
openssl rand -base64 32

Optional (System-level AI providers):

OPENAI_API_KEY='🔑'
ANTHROPIC_API_KEY='🔑'

Optional (AWS Bedrock):

AWS_ACCESS_KEY_ID='🔑'
AWS_SECRET_ACCESS_KEY='🔑'
AWS_REGION='us-east-1'
AWS_MODEL_ID='qwen.qwen3-32b-v1:0'
# AWS_MODEL_ID='qwen.qwen3-coder-30b-a3b-v1:0'

Follow these steps to call the qwen.qwen3-32b-v1:0 model through Amazon Bedrock:

1. Create an AWS account – Sign up at aws.amazon.com if needed.
2. Create an IAM user with programmatic access – In the AWS Console, open IAM → Users → Add users, choose a name, and enable "Programmatic access".
3. Attach Bedrock permissions – Assign a policy similar to:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["bedrock:*", "kms:GenerateDataKey", "kms:Decrypt"],
         "Resource": "*"
       }
     ]
   }

4. Create and store the access keys – Download the access key ID and secret access key once, keep them in a password manager, and map them to AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY.
5. Configure your environment – Set AWS_REGION, optionally override AWS_MODEL_ID, and confirm your Bedrock calls reference qwen.qwen3-32b-v1:0 (or another valid Qwen model ID you prefer).

Once complete, restart the app so the updated credentials are loaded.

Note:

• If ENCRYPTION_KEY is not set, the custom API keys feature will be disabled, but the app will still work using system-level API keys.
• You must provide at least one of: ENCRYPTION_KEY (for user-configured keys) OR system-level API keys (OPENAI_API_KEY/ANTHROPIC_API_KEY).

Start the web app and server in development mode:

npm run dev

Users can configure their own API keys for AI providers through Dashboard Settings:

1. Navigate to Dashboard → Settings → API Keys
2. Configure keys for any supported provider:
   • Anthropic: Access to Claude models (Sonnet, Opus, Haiku)
   • OpenAI: Access to GPT-4.1 series models
   • OpenRouter: Access to multiple AI models with custom model IDs
   • AWS Bedrock: Claude models via AWS infrastructure
3. Optionally specify custom model IDs for each provider
4. API keys are encrypted using AES-256-GCM before storage

Model Selection:

• The chat interface automatically shows available models based on configured API keys
• Users can switch between models using the dropdown in the chat input
• If no model is specified, sensible defaults are provided for each provider

Priority Order: When multiple providers are configured, the system uses this priority: OpenRouter > Anthropic > OpenAI > AWS Bedrock

Users have access to a comprehensive dashboard with:

• Profile Management: Edit name, username, bio, personal website, and social links
• API Keys: Securely configure and manage AI provider credentials
• Sandboxes: View, manage visibility (public/private), and delete projects
• Public Profiles: Each user gets a public profile page at /@username showing their public projects

Anthropic (Claude):

• Claude Sonnet 4.5
• Claude Haiku 4.5
• Claude Opus 4.1
• Claude Sonnet 4
• Claude Opus 4
• Claude Sonnet 3.7
• Claude Haiku 3.5

OpenAI (GPT):

• GPT-4.1
• GPT-4.1 Nano
• GPT-4.1 Mini

OpenRouter & AWS: Custom model IDs supported

GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret

git clone https://github.com/dokku/dokku-daemon
cd dokku-daemon
sudo make install
systemctl start dokku-daemon

DOKKU_HOST=
DOKKU_USERNAME=
DOKKU_KEY=

e2b auth login

npm run templates:deploy -- reactjs

npm run templates:deploy

import { Template } from 'e2b'
import path from 'path'
import { fileURLToPath } from 'url'

const __dirname = path.dirname(fileURLToPath(import.meta.url))

export const template = Template({
  fileContextPath: path.resolve(__dirname),
  fileIgnorePatterns: [".*", "e2b*", "node_modules", "template.ts"],
})
  .fromTemplate("gitwit-base")
  .setWorkdir("/home/user/project")
  .copy(".", "/home/user/project/")
  .runCmd("npm install")

e2b sandbox spawn TEMPLATENAME
cd project

To run the test suite, ensure both web app and server are running.

Set up the following environment variables in the tests/ directory:

GITHUB_PAT=ghp_xxxxxxxxxxxxxxxxxxxxxx
CLERK_TEST_USER_ID=user_xxxxxxxxxxxxxxxxxxxxxx

Note: The CLERK_TEST_USER_ID should match the user ID that was used to sign up and is stored in your PostgreSQL database. You can find this ID in your database's users table or from your Clerk dashboard.

Make sure both web app and server are running, then execute from the project root:

npm run test

The backend server and deployments server can be deployed using AWS's EC2 service. See our video guide on how to do this.

Thanks for your interest in contributing! Review this section before submitting your first pull request. If you need any help, feel free contact us on Discord.

This repository uses Prettier for code formatting, which you will be prompted to install when you open the project. The formatting rules are specified in .prettierrc.

When commiting, please use the Conventional Commits format. Your commit should be in the form category: message using the following categories: