PL
Open source · actively developed

One platform. Many activities. More ways to judge.

AlgoJudge helps teams run programming contests, courses, labs and practice sessions. It accepts submissions, routes them to specialized Runners and brings live results back to participants.

Explore the project on GitHubSee the architecture
One place for the complete workflow

What is AlgoJudge?

A web-first platform that brings activity management, task publishing and automated evaluation together. It is being built for institutions and teams that want to run an instance of their own.

01

Run activities

Contests, courses, labs, workshops and practice sessions in one consistent organizational model.

02

Publish tasks

Statements, attachments, deadlines, limits, scoring and submission policies managed together.

03

Evaluate automatically

Queuing, isolated execution, tests, checkers, points and verdicts that are easy to understand.

The key difference

Beyond a traditional Online Judge

Designed for multiple kinds of activities and multiple ways to evaluate solutions.

New types without changing the central Server

The Client selects a renderer, the Runner selects an evaluation handler, and the Server keeps a shared data envelope. Extensions can live at the edges without coupling the core to task-specific semantics.

Activity types

  • ContestIn development
  • CourseIn development
  • LaboratoryDesigned into the architecture
  • WorkshopDesigned into the architecture
  • PracticeDesigned into the architecture

Task types

  • Standard I/OIn development
  • InteractiveDesigned into the architecture
  • Custom checkersDesigned into the architecture
  • OptimizationDesigned into the architecture
  • Multi-fileDesigned into the architecture
  • Networked and distributedDesigned into the architecture
From an idea to a verdict

How it works

The Server keeps durable state and jobs. Code goes to a replaceable Runner, which evaluates it in an isolated environment and sends the result back.

  1. 1

    Create an activity

    A manager configures a contest or course.

  2. 2

    Add a task

    They publish the statement, files, limits and scoring.

  3. 3

    Open the task

    A participant reads the requirements and format.

  4. 4

    Submit a solution

    Code and metadata are sent to the Server.

  5. 5

    Create a job

    The Server stores the submission and queues work.

  6. 6

    Evaluate in a Runner

    A Runner pulls the job, isolates execution and tests it.

  7. 7

    Show the result

    Live status and the verdict return to the app.

  • Live status updates
  • Isolated code execution
  • Replaceable Runners
  • Durable state in the Server
Client · Server · Runner · Identity

A modular architecture that is not tied to one execution engine

Each component has a clear responsibility. The Server coordinates and stores data, but it never compiles or runs submitted code.

AlgoJudge Client

Interface and renderers

  • Participant and manager views
  • Activity and task renderers
  • Submission forms
  • Result presentation
API and updates

AlgoJudge Server

Data and coordination

  • Activities, tasks and files
  • Permissions and submissions
  • Jobs and results
  • Does not run code

Identity

Identity and access

  • OpenID Connect and OAuth 2.0
  • Institutional SSO
  • Local accounts
  • Short-lived accounts
Authentication

AlgoJudge Runner

Safe execution

  • Pulling evaluation jobs
  • Compilation and isolation
  • Resource limits and tests
  • Score calculation
Outbound connection · works behind NAT

The Server stays generic

It does not know the semantics of a specific task type.

The Runner connects out

It can operate in another network, including behind NAT.

Implementations are replaceable

Different Runners can support different task types.

For education, contests and experiments

One foundation, different use cases

A shared core supports distinct organizational scenarios, while extensibility leaves room for new evaluation models.

Programming contests

Rounds, deadlines, submissions, leaderboards, scoring and live result updates.

Academic courses

Task series, multiple attempts, private results and detailed feedback.

Workshops and events

Quick activities and architecture-ready temporary accounts with expiring access.

New evaluation models

Specialized Runners, extra handlers and renderers — without changes to the central Server.

Built in the open

Explore the AlgoJudge code

The project is developed publicly. Dive into any part of the system, report an issue or help move it forward.

Join development
An honest view of the project stage

Moving forward step by step

AlgoJudge is under active development. The groups below distinguish the current objective, first-release scope and future directions — they do not claim that every feature is ready.

Now

Current objective

Complete the full flow from creating an activity to presenting a result.

  • Activity creation
  • Task publication
  • Solution submission
  • Runner execution
  • Result presentation
First release

MVP scope

The foundations needed for real contests and courses.

  • Contests and courses
  • Standard I/O tasks
  • Verdicts and points
  • History and live statuses
  • Sign-in and temporary accounts
Later

Future development

Directions enabled by the modular architecture.

  • Additional task types
  • More Runner implementations
  • Advanced leaderboards
  • Package import and export
  • LMS, Moodle and LTI integrations
Open source from the first line

Create tasks. Run activities. Help build an open evaluation platform.

Explore the architecture, read the code and help shape a platform that does not lock new ideas into a single evaluation model.

See AlgoJudge on GitHubExplore the architecture