PL
Open source · 0.1 release line

One platform. Many activities. More ways to judge.

AlgoJudge is open-source, self-hosted software for programming contests and courses, with automatic evaluation of submitted solutions.

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

What is AlgoJudge?

A web-first platform that brings activity management, problem publishing and automatic evaluation together. Institutions and teams can run an installation 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, 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

  • ContestAvailable in the 0.1 line
  • CourseAvailable in the 0.1 line
  • LaboratoryDesigned into the architecture
  • WorkshopDesigned into the architecture
  • PracticeDesigned into the architecture

Task types

  • Standard I/OAvailable in the 0.1 line
  • Output-onlyAvailable in the 0.1 line
  • 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.

Academic courses

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

Workshops and events

Quick activities and short-lived 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

Client, Server, Runner, External-Runner and Ops are public, with v0.1.0 released for each component. Explore their code, report an issue or help move the platform forward.

Join development
v0.1.0

AlgoJudge External-Runner

Forwards solutions to external judging systems and reports their verdicts without executing code locally.

View codeReport an issue
v0.1.0

AlgoJudge Ops

The production Compose stack and scripts for installing, updating and backing up a self-hosted deployment.

View codeReport an issue
Independently versioned components

The 0.1 release line is available

AlgoJudge components are versioned independently. Their first releases start at 0.1.0 and together provide a complete self-hosted workflow.

0.1.0

Five independently versioned releases

Client, Server, Runner, External-Runner and Ops each keep their own release history.

  • Client v0.1.0
  • Server v0.1.0
  • Runner v0.1.0
  • External-Runner v0.1.0
  • Ops v0.1.0
Available

The 0.1 foundation

A complete path from activity setup to an automatically evaluated result.

  • Contests and courses
  • Standard I/O and output-only problems
  • Solution submission and isolated Runner execution
  • Verdicts, points, history and live statuses
  • Sign-in, short-lived accounts and self-hosted deployment
Next

Beyond the 0.1 line

Further directions enabled by the modular architecture.

  • Interactive and optimization problems
  • Custom checkers and multi-file projects
  • More specialized Runner implementations
  • Multi-instance Server operation
  • Account API keys and access tokens
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