SM64 Summer League 2025 - Super Mario 64 - 120 Star (All Platforms)

Super Mario 64 - 120 Star (All Platforms)

Scoring Overview

When a league is live, runs are collected from Speedrun.com every few minutes. The system collects only runs that are relevant to the league, i.e. runs submitted by league participants, during the league timeframe.

Once the runs have been collected, each participant's "league PB" is determined, for each category. The league PBs are then ranked, scored, and placed on the league category leaderboards.

In other words, you earn points by improving your league PBs. You don't get more points for simply submitting more runs.

The specific scoring system used for each category is decided by the league creator(s). You can find out more about this category's scoring system in the following sections.

Scoring for this Category

Before scoring, all times will be converted to their N64 equivalent. For each category, your point total is based on three categories: points-per-second, standards and rank. Points-per-second scoring is based on how much you improved your starting pbs. Standards scoring is based on the strength of your league pb, if your league pb is under certain standards you collect a sum for all the standards your pb achieves. Finally, you'll receive a sum based on your relative rank (compared to all participants), those in the top 3/5/10/25 all get an extra sum. Note: you can lose rank points if your rank changes or if you fall out of a top position.

You can look at this google sheet for more intuition about the scoring system: https://docs.google.com/spreadsheets/d/1fevdnPRk2IXzRwLufR-_6NUO8698clziirOLOhvHIbU/edit?usp=sharing

Formula

The formula below shows the exact calculation that is used to score runs for this league category.

The formula is controlled by the admin user(s) running the league. They can make changes to it during the league, if need be.

The syntax you see below is actually valid Python code. This is the actual code that runs in the background when the league is live.

Before reading on, make a note of the following terms:

your "league PB" in a category means your best run submitted during the league
your "initial PB" in a category means your actual PB, as it was at the start of the league

When reading the code below, you may see the following variables being used:

league_pb_rank - the position of your league PB on the league category leaderboard
number_of_league_participants - the total number of participants in the league
league_pb_in_milliseconds - the total time of your league PB, in milliseconds
league_pb_in_seconds_floor - the total time of your league PB, in seconds, rounded down
league_pb_in_seconds_ceiling - the total time of your league PB, in seconds, rounded up
initial_pb_in_milliseconds - the total time of your initial PB, in milliseconds
initial_pb_in_seconds_floor - the total time of your initial PB, in seconds, rounded down
initial_pb_in_seconds_ceiling - the total time of your initial PB, in seconds, rounded up

You may also see the following operators being used:

a * b - a multiplied by b
a ** b - a to the power of b
a // b - how many full lots of a fit into b (also known as "integer divide")
a % b - a modulo b
min(a, b, ...) - the lowest of a, b, ...
max(a, b, ...) - the highest of a, b, ...
abs(a) - the absolute value of a
check_league_pb_var('a', 'b') - 0 or 1, indicating whether the league PB has a variable a with value b
check_initial_pb_var('a', 'b') - 0 or 1, indicating whether the initial PB has a variable a with value b

is_league_pb_n64 = check_league_pb_var('Platform', 'N64')
is_league_pb_emu = check_league_pb_var('Platform', 'EMU')
is_league_pb_n64_or_emu = is_league_pb_n64 + is_league_pb_emu
is_league_pb_vc = abs(is_league_pb_n64_or_emu - 1)

league_pb_in_milliseconds_adjusted = league_pb_in_milliseconds + is_league_pb_emu * 55000
league_pb_in_milliseconds_adjusted = league_pb_in_milliseconds_adjusted + is_league_pb_vc * 110000
league_pb = league_pb_in_milliseconds_adjusted // 1000

is_initial_pb_n64 = check_initial_pb_var('Platform', 'N64')
is_initial_pb_emu = check_initial_pb_var('Platform', 'EMU')
is_initial_pb_n64_or_emu = is_initial_pb_n64 + is_initial_pb_emu
is_initial_pb_vc = abs(is_initial_pb_n64_or_emu - 1)

initial_pb_in_milliseconds_adjusted = initial_pb_in_milliseconds + is_initial_pb_emu * 55000
initial_pb_in_milliseconds_adjusted = initial_pb_in_milliseconds_adjusted + is_initial_pb_vc * 110000
initial_pb = initial_pb_in_milliseconds_adjusted // 1000

has_pb_improved = min(1, max(0, initial_pb_in_milliseconds_adjusted - league_pb_in_milliseconds_adjusted))

pps_1 = 1 * max(0, min(9000, initial_pb) - max(7680, league_pb))
pps_2 = 3 * max(0, min(7680, initial_pb) - max(7200, league_pb))
pps_3 = 4 * max(0, min(7200, initial_pb) - max(6840, league_pb))
pps_4 = 5 * max(0, min(6840, initial_pb) - max(6540, league_pb))
pps_5 = 7 * max(0, min(6540, initial_pb) - max(6300, league_pb))
pps_6 = 9 * max(0, min(6300, initial_pb) - max(6090, league_pb))
pps_7 = 12 * max(0, min(6090, initial_pb) - max(5910, league_pb))
pps_8 = 18 * max(0, min(5910, initial_pb) - max(5790, league_pb))
pps_9 = 36 * max(0, min(5790, initial_pb) - max(0, league_pb))
pps = pps_1 + pps_2 + pps_3 + pps_4 + pps_5 + pps_6 + pps_7 + pps_8 + pps_9

tier_1 = 75 * min(1, max(0, 35999 - league_pb))
tier_2 = 100 * min(1, max(0, 10800 - league_pb))
tier_3 = 150 * min(1, max(0, 9600 - league_pb))
tier_4 = 200 * min(1, max(0, 8400 - league_pb))
tier_5 = 250 * min(1, max(0, 7500 - league_pb))
tier_6 = 350 * min(1, max(0, 7050 - league_pb))
tier_7 = 450 * min(1, max(0, 6600 - league_pb))
tier_8 = 600 * min(1, max(0, 6240 - league_pb))
tier_9 = 750 * min(1, max(0, 6000 - league_pb))
tier_10 = 1000 * min(1, max(0, 5850 - league_pb))
tier_11 = 1500 * min(1, max(0, 5728 - league_pb))
standards = tier_1 + tier_2 + tier_3 + tier_4 + tier_5 + tier_6 + tier_7 + tier_8 + tier_9 + tier_10 + tier_11

rank_score = 3 * max(0, number_of_league_participants + 1 - league_pb_rank)
top3_sum = 50 * min(1, max(0, 4 - league_pb_rank))
top5_sum = 40 * min(1, max(0, 6 - league_pb_rank))
top10_sum = 30 * min(1, max(0, 11 - league_pb_rank))
top25_sum = 20 * min(1, max(0, 26 - league_pb_rank))
rank = rank_score + top3_sum + top5_sum + top10_sum + top25_sum

score = pps + standards + rank

final_score = has_pb_improved * score

Calculator

You can try the scoring system out for yourself, using this calculator. Plug in some hypothetical (or actual) speedrun details, and see how much it would score.

This can help you get a feel for the scoring system. It can also be useful throughout the league. For example, you can experiment with it, when deciding which league categories to focus on next.

Note that having no initial PB is equivalent to having an initial PB of 999h 59m 59s 999ms.

Initial PB:

Platform:

League PB:

Platform:

Rank

out of

participants

(321 participants currently registered for this league)

Result