PL
Open source · 0.2 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 problems

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 problem-specific semantics.

Activity types

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

Problem types and judging modes

  • Standard I/OAvailable in the 0.2 line
  • Output-onlyAvailable in the 0.2 line
  • Interactive judging in standard-io@1Available in the 0.2 line
  • Custom checkers in standard-io@1Available in the 0.2 line
  • 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 problem

    They publish the statement, files, limits and scoring.

  3. 3

    Open the problem

    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 problem renderers
  • Submission forms
  • Result presentation
API and updates

AlgoJudge Server

Data and coordination

  • Activities, problems 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 problem type.

The Runner connects out

It can operate in another network, including behind NAT.

Implementations are replaceable

Different Runners can support different problem 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

Problem 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.

Open source under the MIT License

Explore the AlgoJudge code

Client, Server, Runner, External-Runner, Ops and Docs are public under the MIT License, with v0.2.0 released for each repository. Explore their code, report an issue or help move the platform forward.

Join development
v0.2.0

AlgoJudge External-Runner

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

View codeReport an issue
v0.2.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.2 release line is available

AlgoJudge components are versioned independently. Their first releases started at 0.1.0; the current v0.2.0 releases together provide the complete self-hosted workflow.

0.2.0

Six independently versioned releases

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

  • Client v0.2.0
  • Server v0.2.0
  • Runner v0.2.0
  • External-Runner v0.2.0
  • Ops v0.2.0
  • Docs v0.2.0
Available

The current 0.2 line

The complete workflow now includes broader local evaluation and course-platform integration.

  • Contests, courses and LTI 1.3 integration verified with Moodle
  • Standard I/O and output-only problem types
  • Eighteen local language toolchains
  • Custom checkers and interactors in standard-io@1
  • Isolated execution, verdicts, points, history and live statuses
Next

0.1 history and future directions

The 0.1 line established the self-hosted foundation. The modular architecture leaves further extensions open.

  • Optimization, multi-file, networked and distributed problems
  • More specialized Runner implementations
  • Multi-instance Server operation
  • Account API keys and access tokens
Open source from the first line

Create problems. 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