---
title: Challenge editor
description: Every challenge field, covering flags, scoring methods, runtime, hints, files, and prerequisites.
---

One form powers **Add challenge** on the Challenges page and the draft editor, with the sections in the order below. Editing an existing challenge uses the same fields, split across sections that save one at a time: **Details and scoring**, **Runtime setup**, **Flag**, **Hints**, **Files**, **Prerequisites**.

## Basics

- **Challenge Title**: required, up to 200 characters.
- **Description**: required; a rich-text editor for the challenge prompt.
- **Category** and **Difficulty**: required selects. Their options are yours to define per event on the **Categories** and **Difficulties** dashboard pages, where you create, rename, and delete entries (each shows how many challenges use it).
- **Points**: required, a whole number of at least 1; default 100. With a decay scoring method this acts as the starting value unless you set **Initial Points** explicitly (below).
- **Enable Attempt Limit**: off by default. When on, a **Max Attempts** field (a whole number, 0 or more) caps the submissions allowed on this challenge. The cap is counted **per team** (in a solo event that's per player), and **every submission counts, correct or not**. Turning the switch back off removes the cap.

## Access

- **Prerequisites**: pick challenges players must solve first; add as many as needed, and remove one with the ✕ on its chip. On an existing challenge each add and remove saves on its own; on a new challenge or a draft they save with the rest of the form.
- **Show user solves**: *"Display who solved this challenge to players."* On an existing challenge this control sits with Details and scoring and saves with **Save details**.

Whether a challenge is on the board, and when, is **not** an editor field. Releasing, scheduling, locking and unlocking are actions on the challenge's own page under **Lifecycle**, so an ordinary save can never change what players can see. See [Release challenges in waves](/organizers/how-to/release-challenges-in-waves) for the whole lifecycle.

## Saving an existing challenge

The editor saves **per section**. Details and scoring share one **Save details** button that sends only the fields you changed; the flag, each hint, each attachment and each prerequisite save on their own. A failure in one section leaves the others untouched, and the message names what went wrong.

Three rules worth knowing before you edit:

- **Editing a hint keeps every team's unlock.** Changing a penalty applies to future unlocks only; teams that already paid keep what they paid.
- **Deleting a hint refunds it.** If a hint gives too much away, delete it: every team that unlocked it gets back exactly the points it spent, and their totals move immediately. You never have to choose between leaving a bad hint up and leaving players out of pocket.
- **The stored flag can't be shown.** Leaving the **Flag** section alone keeps the current answer key; saving it replaces it. Switching a challenge from dynamic to static also clears the per-team flags that were issued.

## Scoring method

Three methods, with the formula shown right in the form:

| Method | Behavior |
|---|---|
| **Static (Fixed Points)** | *"Points remain constant regardless of solves or time"* |
| **Solve Rate Based (Decay per solve)** | *"Points decay per solve. Formula: initial × (1 − decay/100)^solves"* |
| **Time Based (Decay over time)** | *"Points decay over elapsed days. Formula: initial × (1 − decay/100)^days"* |

The two decay methods share three parameters:

- **Initial Points**: the starting value. Left empty (or 0), the challenge's base **Points** is used.
- **Minimum Points**: the floor; decay never takes the value below it.
- **Decay Factor (%)**: 0–100. Each solve (or day) multiplies the value by `1 − decay/100`; at 100 the value drops straight to the minimum.

Two things to know when choosing time-based decay:

- Days elapsed are counted fractionally, so the value declines continuously rather than in daily steps.
- The clock runs from when the challenge is **created**, not from the event start or the challenge's release time. If you author challenges well in advance, use solve-rate decay, or create the time-based ones close to when their clock should start.

For guidance on picking between these, see [Designing your scoring](/organizers/explanation/designing-scoring).

## Hints and Files

- **Hints**: each hint is a text plus a **Penalty** (points, 0 or more) players pay to reveal it. **Add Hint** appends a row; hints reach players in row order. Blank hint rows are dropped on save, so the starter row is safe to leave empty.
- **Files**: drag-and-drop or **Select Files**. Accepted types: `.zip`, `.tar`, `.gz`, `.txt`, `.pdf`, `.md`, `.json`, each up to **10 MB**, multiple files allowed. After upload you can edit a file's display name inline; that's the name players see.

## Flags

Each challenge has exactly one flag, set by **Flag Type**:

- **Static**: you provide the **Flag Content**, and a **Case Sensitive** checkbox (off by default) controls whether submissions must match its casing exactly.
- **Dynamic**: there is no content to type. The platform generates a distinct flag for each team, delivered through the challenge's container instance, so flags shared between teams don't work. A team's flag is created when it first launches an instance of the challenge and stays the same for that team for the whole event. Dynamic flags are always case-sensitive, and require a container runtime; the form reminds you: *"Dynamic flags require runtime container configuration."*

Once a flag is saved it is never shown again; the stored flag is hashed. When you reopen a challenge the **Flag** section starts empty and saves independently of everything else, so leaving it alone keeps the current answer key and pressing **Save flag** replaces it. Switching a challenge from dynamic to static also clears the per-team flags already issued, so every team validates against the new one.

On Extra Small events only static flags are available; the type selector doesn't appear, and validation rejects anything else with *"Extra Small events only support static flags."*

## Runtime setup

Choosing a dynamic flag reveals this section. As the form states: each instance runs all services together on one host, services reach each other via `127.0.0.1`, and up to **2 ports** can be opened per instance, across at most **5 services**, with each port either web or TCP.

**Task size** sets the compute for the whole instance, and every service in the challenge shares it:

| Size | Compute | Cost |
| --- | --- | --- |
| Small | 0.25 vCPU / 512 MB | 1× instance hours |
| Medium | 0.5 vCPU / 1024 MB | 2× instance hours |
| Large | 1 vCPU / 2048 MB | 4× instance hours |
| Extra large | 2 vCPU / 4096 MB | 8× instance hours |

The selector appears once the challenge has at least one service, and challenges default to Small. The multiplier applies to the instance hours a running instance consumes, so a Large instance running for an hour bills 4 IH.

The **event's size** caps the largest task size allowed: an Extra Small event allows Small only, Small allows up to Medium, Medium allows up to Large, and Large and Extra Large allow all four. Saving a challenge above the cap is rejected, and the message names the task sizes the event allows.

**Add Service** adds up to 5 services, each with:

- **Name**: lowercase letters, digits, and dashes, starting and ending with a letter or digit, up to 63 characters. The first service defaults to `main`. Two services can't share a name.
- **Image**: one of the event's successfully built images ([Build challenge images](/organizers/how-to/build-challenge-images)); nothing else can be selected.
- **Start command**: optional; overrides the image's default command. It's split on spaces into arguments.
- **Open ports**: **Add port** adds a row per container port players connect to. Each row takes the port number and its kind: **Web** for something that opens in a browser, **TCP** for a raw socket players point a tool at. New rows start as **TCP**, so switch a browser-facing port to **Web**. Each port must be between 1 and 65535, no port may be listed twice, and **2 total across all services** is the ceiling; a row left blank or outside that range is rejected on save.
- **Environment variables**: key/value pairs for your container, up to **100 per service**. Names must start with a letter or underscore and contain only letters, digits, and underscores. `FLAG` and `FLAG_FULL` are reserved: the platform sets them with the team's flag, and saving your own value for either is rejected.

The end-to-end walkthrough is [Run a container challenge](/organizers/tutorials/run-a-container-challenge).

## Saving and publishing

The submit bar depends on where you are:

- **Create Challenge** and **Save as Draft**: on a new challenge. Create Challenge validates and creates the challenge **hidden**, ready for you to release; Save as Draft stores the form as-is with no validation (confirming with a *"Draft saved"* toast) and moves you into the draft editor.
- **Publish Challenge**: in the draft editor; runs full validation and turns the draft into a **hidden** challenge. Showing it is a separate step under **Lifecycle** on the challenge's own page.

There is no whole-form save when editing an existing challenge; each section has its own button (**Save details**, **Save runtime**, **Save flag**, **Save hint**) and files and prerequisites apply as you add or remove them.

In the draft editor your edits **autosave** shortly after you leave a field, so there is no save button; progress persists on its own. A small indicator next to Publish tracks it (**Unsaved changes**, then **Saving…**, then **Saved**), and autosaving is silent (no toast). Autosave stores the draft as-is; only Publish validates.

When validation fails, a summary panel lists each missing or invalid field so you can fix them in one pass.
