CodeForge AI

Your AI-powered coding interview prep workspace

LeetCode-style DSA problems · An instant online compiler · Frontend sandbox challenges · Live contests · Personalized roadmaps · Spaced-repetition revision · A community forum · Local mock interviews · A real-time streaming AI Mentor — all in one cohesive developer workspace.

Getting Started · Features · Tech Stack · Changelog · Deployment

_{About · Contact · Changelog · Privacy · Terms}

CodeForge AI is a single Next.js 15 (App Router) application that serves the UI, the API, and background work from one codebase. It follows a layered design — route handlers → service layer → data/integration layer — so that providers (code runners, AI, payments) are swappable behind interfaces and the app degrades gracefully when any optional integration is absent.

graph TD
    User(["User Browser"]) -->|HTTPS / SSE| Edge

    subgraph Client ["Client (React 19)"]
        Editor["Monaco Editor — DSA"]
        Sandbox["Sandpack — Frontend"]
        AIChat["AI Mentor Panel (streamed)"]
        UI["Pages • Zustand • React Query"]
    end
    User --> Client

    Edge["Edge Middleware<br/>auth gate • CORS • security headers"]
    Client -->|Server Actions / fetch| Edge
    Edge --> Routes["Route Handlers (/api/*)"]

    Routes --> Auth["Supabase Auth<br/>Email/Password • Google • GitHub • Passkeys"]
    Routes --> Services["Service Layer"]

    subgraph Services2 ["Service Layer (src/services)"]
        Q["questions / contests / challenges"]
        Exec["execution (provider router)"]
        AIsvc["ai (Groq prompts + stream)"]
        Game["gamification (XP • badges • streaks)"]
        Stats["stats / roadmaps / companies"]
    end
    Services --> Services2

    Services2 --> DB[("Supabase Postgres<br/>33 tables · RLS")]
    Services2 --> Storage[("Supabase Storage<br/>résumés • covers • avatars")]
    Services2 --> Redis[("Upstash Redis<br/>rate-limit • leaderboard cache")]

    Exec --> Paiza["Paiza.io (default)"]
    Exec --> Judge0["Judge0 CE (RapidAPI)"]
    Exec --> Piston["Piston (self-hosted)"]

    AIsvc --> Groq["Groq — Llama 3 (streaming)"]
    Routes --> Razorpay["Razorpay (subscriptions)"]
    Routes --> Mailer["Nodemailer / SMTP"]
    Routes --> GH["GitHub Issues (feedback)"]

1. Edge middleware (src/middleware.ts) runs first on every request. It validates the Supabase Auth session (getClaims) against a public-route allowlist, enforces same-origin/CORS on mutating requests, and attaches security headers (CSP, HSTS, X-Frame-Options: DENY).
2. Route handlers under src/app/api/* validate input with Zod, resolve the session, and apply rate limiting (Upstash sliding window, with an in-memory fallback) before doing work.
3. Service layer (src/services/*) holds the business logic — question/contest queries, the execution-provider router, AI prompt orchestration, gamification, and stats — keeping handlers thin. Each data module reads/writes through a backendFor() flag, a legacy of the MongoDB→Supabase migration that still allows an instant rollback.
4. Data & integrations — Supabase Postgres persists state (33 tables, row-level security, service-role backend) and Supabase Storage holds uploads; Redis caches hot reads (leaderboards) and rate-limit counters; external providers (Groq, Razorpay, SMTP, GitHub, code runners) are called through small adapter modules in src/lib and src/services.

sequenceDiagram
    participant U as User
    participant API as /api/execute
    participant R as Execution Router
    participant P as Provider (Paiza / Judge0 / Piston)
    participant DB as Supabase Postgres

    U->>API: source + language + stdin (test cases)
    API->>API: Zod validate • auth • rate-limit
    API->>R: run(language, source, input)
    R->>P: submit job (selected by EXECUTION_PROVIDER)
    P-->>R: stdout / stderr / status
    R->>R: normalize verdict (AC / WA / TLE / RE)
    R-->>API: per-test results
    API->>DB: persist Submission (+ XP, streak, badges)
    API-->>U: verdict + diff + metrics

The provider is chosen at runtime by EXECUTION_PROVIDER; all providers conform to one interface in src/services/execution, and outputs pass through a normalize step so verdicts are consistent regardless of backend. The standalone Online Compiler at /api/compiler reuses the same provider router — it executes a single program with optional stdin and returns raw stdout/stderr plus runtime and memory, skipping the test-case/verdict step.

The AI panels post the problem, code buffer, and runtime output to streaming routes under /api/ai/*. The ai service composes a system prompt (progressive-hint policy) and forwards to Groq (Llama 3), relaying tokens to the client over Server-Sent Events for real-time rendering. If GROQ_API_KEY is absent, the routes short-circuit and the UI shows inline setup guidance instead of failing.

Every external dependency is optional and isolated, so a missing key degrades one feature rather than breaking the app: no Redis → in-memory rate-limit + on-demand leaderboard from Mongo; no Groq → AI panels show setup help; no Razorpay → billing hidden; no SMTP/GitHub → feedback and emails fall back or no-op; DB unreachable at build → robots.txt/sitemap.xml render dynamically rather than crashing the build.

Accounts, Auth & Settings — Supabase Auth with email/password, Google & GitHub OAuth, and passwordless passkeys (Face ID / Touch ID / security keys). A guided onboarding flow, a working forgot/reset-password flow, and a comprehensive 7-tab Settings hub: Profile (avatar + cover photo with a safe-zone guide), Account (linked methods + change password), Security (passkeys), Appearance (light/dark/system), Editor, Notifications, and Billing.

Docs & Transparency — Browsable OpenAPI/Swagger docs at /docs, plus first-class Changelog, Pricing, Privacy & Terms pages.

• Node.js ≥ 18.x
• A Supabase project (the free tier is plenty)
• Redis (optional — falls back to in-memory store)
• Groq API Key (optional — enables AI mentor & tools)

# 1. Install dependencies
npm install

# 2. Configure environment
cp .env.example .env.local

Set the required variables in .env.local:

# Database connection
MONGODB_URI="mongodb+srv://..."

# Auth secret — generate with: openssl rand -base64 32
AUTH_SECRET="your-generated-auth-secret"

# 3. (optional) Seed starter questions
npm run seed

# 4. Start the dev server
npm run dev

Open http://localhost:3000 to preview the app.

1. Become an admin — add your email to ADMIN_EMAILS, then register at /register.
2. Add questions — in Admin → Questions: Generate with AI, Upload JSON, or run npm run seed.
3. Publish — flip the Published switch on questions to make them visible.
4. Test run — open a problem at /problems, pick a language, and Run Code.

A single ExecutionProvider interface wraps multiple backends — switch instantly via EXECUTION_PROVIDER:

• Paiza (default) — zero-config, no API key. Great for local dev.
• Judge0 CE — high-concurrency sandbox via RapidAPI. Needs JUDGE0_API_KEY.
• Piston (self-hosted) — isolated, Dockerized cluster. Needs PISTON_URL.

• No Groq → AI panels show inline setup help; editor, runs & metrics still work.
• No Redis → in-process cache; rankings computed from Postgres on demand.
• No Razorpay → payments disabled gracefully; free/beta flows still work.
• No OAuth → provider buttons hidden; email/password remains.

npm test          # Unit & component tests (Jest)
npm run test:e2e  # End-to-end tests (Playwright)
npm run lint      # Static analysis (ESLint)
npm run typecheck # Type-check without emitting

The complete, always-current release history lives in-app — currently v3.3.0:

View the Changelog (or /changelog on your deployment)

Every release — new features, improvements and fixes — is documented there with version, date and tags. Recent highlights: the full MongoDB → Supabase migration (Postgres, Auth, Storage), passwordless passkeys, a redesigned auth experience, profile avatar + cover photos, and a 7-tab Settings hub.

Optimized for Vercel out of the box:

1. Import your GitHub repository to Vercel.
2. Add all required environment variables.
3. Deploy — the bundled vercel.json configures Serverless Function timeouts for execution and streaming AI routes.

CodeForge AI is founded, designed and built by Nitheesh Rajendran — Founder & Developer — under Setups Works.

Founder of CodeForge AI (codeforgeai.io).

Founder of Setups Works (setups.works).

Built with care by

_{Licensed under the MIT License}