🚀 AlgoDojo
Master Data Structures & Algorithms with clarity, visualization, and execution intelligence.
AlgoDojo is a modern, execution-aware DSA learning platform that combines a professional online code editor, secure multi-language execution, automatic complexity analysis, and step-by-step visualizations.
Unlike traditional problem platforms, AlgoDojo focuses on understanding how algorithms execute, not just getting the correct answer.
🌟 Why AlgoDojo?
Learning DSA today is often:
Text-heavy and non-visual
Focused on memorization over understanding
Fragmented across multiple tools
Expensive for advanced features
AlgoDojo solves this by providing:
🧑💻 VS Code–grade online editor
🐳 Secure multi-language code execution
📊 Automatic time & space complexity analysis
🎥 Step-by-step execution visualization
📚 Curated problem sets by pattern
📈 Learning progress tracking
🧠 Pattern-aware intelligence layer (future)
🏗 Architecture Overview
AlgoDojo follows a service-oriented backend architecture designed for scalability, safety, and clarity.
Frontend (React + Monaco) | v Main API (Node.js + Fastify) | ├── PostgreSQL (Prisma ORM) ├── Redis + BullMQ (Queue & Cache) ├── Code Execution Service (Docker Sandboxes) ├── Complexity Engine (Python FastAPI) └── Object Storage (S3-compatible) 🖥 Tech Stack Frontend
React 18
TypeScript
Vite
TailwindCSS
shadcn/ui (Radix primitives)
Monaco Editor
TanStack Query
Framer Motion
Backend
Node.js 20+
Fastify
TypeScript
PostgreSQL
Prisma ORM
Redis
BullMQ
Docker (sandboxed execution)
Complexity Engine
Python
FastAPI
AST-based static analysis
Observability
Sentry
Prometheus
Grafana
Pino Logger
🔁 How It Works (Execution Flow) 🧪 Run Code
User writes code in Monaco editor.
Clicks Run.
Frontend sends submission to Backend API.
Backend:
Stores submission
Pushes job to Redis queue
Worker:
Spins up isolated Docker container
Executes code safely
Captures output, metrics, execution trace
Results stored in DB.
Frontend fetches:
Output
Trace
Complexity analysis
Visualizer animates execution.
🐳 Secure Code Execution
User code is executed in isolated Docker containers with:
CPU limits
Memory limits
Timeout enforcement
No network access
No filesystem access
This ensures safe execution of untrusted code.
📊 Complexity Analysis
The Complexity Engine:
Parses user code into AST.
Detects:
Loops
Nested loops
Recursion
Auxiliary space usage
Generates:
Time complexity (Big-O)
Space complexity
Human-readable explanation
📚 Problem System
Problems are:
Curated and pattern-based
Tagged (arrays, DP, graphs, etc.)
Authored internally (no scraping)
Include:
Description
Examples
Starter code
Hints
Admin dashboard manages problem creation.
🧠 Learning Philosophy
AlgoDojo is designed around:
Execution visibility
Pattern recognition
Complexity reasoning
Long-term retention
Future intelligence layer will include:
Thinking pattern detection
Solution fingerprinting
Adaptive problem sequencing
Execution divergence comparison
📂 Project Structure Frontend src/ ├── pages/ ├── components/ ├── hooks/ ├── lib/ ├── App.tsx └── main.tsx Backend backend/ ├── prisma/ ├── src/ │ ├── modules/ │ ├── workers/ │ ├── config/ │ ├── lib/ │ ├── middlewares/ │ ├── app.ts │ └── server.ts ├── Dockerfile └── docker-compose.yml ⚙️ Environment Setup
Create .env inside /backend:
NODE_ENV=development PORT=3000
DATABASE_URL=postgresql://algodojo:algodojo@localhost:5432/algodojo REDIS_URL=redis://localhost:6379
JWT_SECRET=generate_strong_secret JWT_REFRESH_SECRET=generate_strong_secret JWT_EXPIRES_IN=15m JWT_REFRESH_EXPIRES_IN=7d
COMPLEXITY_ENGINE_URL=http://localhost:8000 CORS_ORIGIN=http://localhost:5173 🛠 Running Locally 1️⃣ Start Backend Services cd backend npm install docker-compose up -d npm run prisma:generate npm run prisma:migrate npm run dev
Backend runs on:
http://localhost:3000 2️⃣ Start Frontend npm install npm run dev
Frontend runs on:
http://localhost:5173 🔌 API Endpoints Auth
POST /api/auth/signup
POST /api/auth/login
POST /api/auth/refresh
GET /api/auth/me
Problems
GET /api/problems
GET /api/problems/:id
POST /api/problems (admin)
Submissions
POST /api/submissions
GET /api/submissions/:id
🧪 Testing Strategy
Unit tests for services
Integration tests for API routes
Worker queue testing
Sandbox execution validation
Complexity engine validation
🔐 Security Considerations
JWT authentication
Rate limiting
Docker sandbox isolation
Admin role enforcement
Input validation with Zod
Observability for crash detection
🚀 Roadmap MVP
Code execution
Visualization
Complexity engine
Problem system
Progress tracking
Phase 2
AI thinking-pattern detection
Adaptive learning
Execution comparison
OAuth integration
Phase 3
Multi-language expansion (C++, Java)
Collaborative sessions
Educator dashboard
AI-assisted feedback
🤝 Contributing
Fork the repo
Create feature branch
Write clean, typed code
Add tests
Submit PR
📜 License
MIT License