[opensourcedex]

ClassroomIO is a free, open source learning management systems (lms) project written in TypeScript and released under AGPL-3.0. It has 1,686 GitHub stars, 388 forks and 46 open issues, and was last pushed 8 hours ago. On this registry it ranks #4 of 6 tracked projects in Learning Management Systems (LMS), with 5 head-to-head comparisons available. It gained 2 stars over the last 6 tracked days.

What is ClassroomIO?

What it is

ClassroomIO is an open-source learning management system for companies, built in the TypeScript web-application ecosystem with SvelteKit, Hono, PostgreSQL, Better Auth, and TailwindCSS. It supports branded academies for employees, customers, or partners, and it can be self-hosted or used through a hosted cloud version.

The concrete problem it addresses is running structured learning programs without depending only on external classroom or course platforms. It supports compliance training, customer education, and partner certification cohorts from one platform, covering courses, learner progress, certificates, deadlines, waivers, renewals, and integrations.

Key capabilities

  • Course management supports unlimited courses, lessons, exercises, grading, and certificates, so an organization can build and deliver training paths.
  • Cohorts group courses into cohorts with goals, team management, and progress tracking, helping coordinate training for employee, customer, or partner groups.
  • Compliance tracking records status, deadlines, grace periods, renewals, and waivers, and it issues branded certificates with custom identifiers.
  • Multi-organization and multi-teacher workflows let administrators invite teachers, assign courses, manage multiple organizations, and give learners a dashboard for courses, assignments, and progress.
  • AI-assisted tools include a course builder that can generate outlines, lesson content, and assignments using Gemini, GPT-4o, or Claude, plus an in-lesson tutor.
  • Developer integration uses a REST API and webhooks for events such as certificate.issued and enrollment.completed, an embeddable course-catalog widget, and the @classroomio/mcp server on npm.

Who uses it and how

  • Companies use it for compliance and employee training when they need deadline tracking, renewals, retake intervals, grace periods, waivers, and certificates with custom identifiers.
  • Customer education teams use it as a branded academy portal, organizing learners into cohorts with goals and offering multilingual content and an AI lesson tutor.
  • Partner training programs use it to create partner workspaces, branded certificates, custom domains, embeddable widgets, and multilingual support for external organizations.
  • Learning operations teams use the student dashboard, course management, grading, and certificates to manage learner progress inside the same system.
  • Developers and automation teams use the REST API, webhooks, embeddable widget, and MCP server to connect ClassroomIO to enrollment flows, external websites, and AI tools.

Getting started

Install Node.js 20.19.3 or later and pnpm v10, clone the repository, and use Docker to run PostgreSQL and Redis for local development; ClassroomIO also offers a hosted cloud version.

When to use it — and when not to

Compared with hosted platforms such as Coursera and Google Classroom, ClassroomIO gives an organization control over data and branding, but a self-hosted deployment requires the operator to run PostgreSQL, Redis, email and notification services, and PDF or video processing. The metadata shows a very young repository, zero listed contributors, and 46 open issues, so a production deployment should verify support and maintenance before relying on it.

project readme (upstream, from github) — read inline
ClassroomIO is a no-code tool that allows you build and scale your online bootcamp with ease.

ClassroomIO.com

The Open Source Learning Management System for Companies
Website | Join Discord community

✨ About ClassroomIO.com

ClassroomIO Courses page

ClassroomIO is an open source LMS for companies. Run compliance/employee training, customer education, and partner certification cohorts — all from one platform. Self-host it on your own infrastructure or use the cloud version.

Who It's For

Use Case What You Get
Compliance Training Deadline tracking, renewals & retake intervals, grace periods, waivers, certificates with custom IDs
Customer Education Branded academy portal, cohorts (cohorts with goals), AI lesson tutor, multilingual content
Partner Training Partner workspaces, branded certificates, custom domains, embeddable widgets, multilingual support

Key Features

Course & Content

  • Course management — unlimited courses, lessons, exercises, grading, and certificates
  • Cohorts — group courses into cohorts with goals, team management, and progress tracking
  • AI Course Builder — generate outlines, lesson content, and assignments (Gemini, GPT-4o, Claude)
  • AI Lesson Tutor — in-lesson AI assistant that helps learners as they study

Compliance & Certification

  • Compliance tracking — status, deadlines, grace periods, renewals, and waivers
  • Certificates — issue branded certificates with custom IDs

Learner & Org Experience

  • Multi-org & multi-teacher — invite teachers, assign courses, manage multiple organizations
  • Student dashboard — learners access all courses, assignments, and progress in one place
  • Multilingual — deliver content in 10+ languages

Integrations & Developer Tools

  • REST API + Webhooks — enroll users, trigger automations, receive events (certificate.issued, enrollment.completed, and more)
  • MCP server — @classroomio/mcp on npm for AI-native integrations
  • Embeddable widget — embed your course catalog on any website

Platform

  • Fully open source — self-host the entire stack on your own servers

For what's coming next, see the public roadmap.

Built With

Get a Demo

You can book a quick 15 min demo to see if ClassroomIO is a good fit for you

Book a Call with ClassroomIO.com

Getting Started

To get a local copy up and running, please follow these simple steps.

Prerequisites

Here is what you need to be able to run ClassroomIO.com

  • Node.js (Version: >=20.19.3) — required
  • pnpm (v10) — required; the package scripts call pnpm directly, so npm/yarn are not substitutes
  • Docker — required; runs Postgres + Redis (no local install of those needed)

Project Structure

This repo is a monorepo that consists of these primary apps:

  1. website: The landing page of ClassroomIO hosted here
  2. api: The api service that handles PDF, video processing, Emailing and Notifications.
  3. dashboard: The web application that runs the learning management system hosted here.
  4. docs: Official documentation of ClassroomIO hosted here

The repository also contains shared packages under packages/ (for example packages/db, packages/utils, and packages/ui).

Development

Local Setup

Before you start: make sure pnpm and Docker are installed (see Prerequisites). New to the project? Read DEV_SETUP_NOTES.md first — it's a full step-by-step walkthrough with a troubleshooting reference for the errors you're likely to hit.

  1. Fork the repo, then clone it:

    git clone https://github.com/classroomio/classroomio.git

  2. Go to project folder:

    cd classroomio

  3. Set up Node (using nvm):

    nvm use

    You first might need to install the specific version and then use it:

    nvm install && nvm use

    You can install nvm from here.

  4. Install dependencies:

    pnpm i

  5. Set up your .env files:

    Each app reads its own .env. In apps/api, apps/jobs and apps/dashboard, duplicate .env.example to .env and fill the values below (host ports). The secret values are placeholders — generate each one with openssl rand -hex 32 rather than copying the example text. The two PRIVATE_SERVER_KEY values must match — they authenticate the dashboard's server-to-server calls to the API, so generate it once and paste the same value into both files.

    • apps/api/.env:

      DATABASE_URL="postgresql://postgres:postgres@localhost:5432/classroomio"
REDIS_URL="redis://localhost:6379"
PUBLIC_SERVER_URL="http://localhost:3002"
TRUSTED_ORIGINS="http://localhost:5173"        # the dashboard dev origin
BETTER_AUTH_SECRET=""
PRIVATE_SERVER_KEY=""   # generate once; use the SAME value in the dashboard
DASHBOARD_ORIGIN="http://localhost:5173"        # optional; used for invite/email links back to the dashboard

    • apps/jobs/.env: The jobs service handles background tasks (emails, media processing, analytics rollups, etc.).

      Recommended setup (simplest):

      cd apps/jobs
ln -s ../../apps/api/.env .env

    • apps/dashboard/.env:

      PUBLIC_SERVER_URL="http://localhost:3002"
PRIVATE_SERVER_URL="http://localhost:3002"      # used by the SSR auth proxy — required, or login returns "API upstream not configured"
PRIVATE_SERVER_KEY=""   # must match the API (paste the value generated above)
PUBLIC_IS_SELFHOSTED=false

    • Running the background workers? Also create apps/jobs/.env (e.g. cp apps/api/.env apps/jobs/.env); it needs REDIS_URL. The packages/db/.env used by the DB scripts is set up in step 6.

    • Optional for self-hosted Enterprise-only features (SSO, token-auth, no-tracking): set LICENSE_KEY in apps/api/.env.

    • Optional upload size limits: set matching UPLOAD_MAX_*_MB values in both apps/api/.env and apps/dashboard/.env (see apps/api/.env.example). Defaults are 5 MB documents, 2 MB assignment files, 800 MB videos.

  6. Start local infrastructure for API (Postgres + Redis) and seed the DB:

    docker compose -f docker-compose.yaml up -d postgres redis
cp packages/db/.env.example packages/db/.env   # one-time (Windows: Copy-Item)
pnpm --filter @cio/db db:setup:seed
    • Connect with DATABASE_URL=postgresql://postgres:postgres@localhost:5432/classroomio
    • Connect with REDIS_URL=redis://localhost:6379
    • db:setup:seed creates the schema and seeds demo data once Postgres is up. The db scripts run with their own working directory, so they read DATABASE_URL from packages/db/.env (not apps/api/.env).

  7. (Optional) Start MinIO locally for object storage (media/documents):

    docker compose -f docker-compose.yaml --profile minio up -d minio minio-init
    • Console Web UI: http://localhost:9001 (user/pass default minioadmin / minioadmin). Open in browser and select Object Browser to view buckets and uploaded files.
    • S3 endpoint: http://localhost:9000
    • Buckets created by minio-init: videos, documents, media
    • Browser presigned uploads work out of the box: Compose passes MINIO_API_CORS_ALLOW_ORIGIN (default *) from the root .env to the MinIO container — set it there if you need to restrict origins.
    • Add to apps/api/.env when using MinIO locally:
      • OBJECT_STORAGE_ENDPOINT=http://localhost:9000
      • OBJECT_STORAGE_PUBLIC_ENDPOINT=http://localhost:9000
      • OBJECT_STORAGE_ACCESS_KEY_ID=minioadmin
      • OBJECT_STORAGE_SECRET_ACCESS_KEY=minioadmin
      • `OBJECT_STORAGE_FORCE_PATH_

readme truncated — read the full docs on github

Frequently asked questions

Is ClassroomIO free to use?

ClassroomIO is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does ClassroomIO do?

Build your custom learning academy in minutes

What is ClassroomIO written in?

ClassroomIO is primarily written in TypeScript. Its source is publicly available at https://github.com/rotimi-best/classroomio, and it has 1,686 GitHub stars.