Skip to content
Athena User Guide
Esc
↑↓navigate↵open⌘Jpreview
On this page

Challenge editor

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

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); 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.

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.

Was this page helpful?