Skip to main content

02 - Polars vs pandas: Benchmarks on 20 Million Rows

Polars 2.1.0 against pandas 3.1.1 on 20 million rows, with reproducible measurements: where the gain is tenfold, where it is nil and how to migrate safely.

What do you think about this article?

02 - Polars vs pandas: Benchmarks on 20 Million Rows
Data Engineering 2027Photo:Atlantic AmbiencePexels

At a Glance

Polars 2.1.0 against pandas 3.1.1 on 20 million rows, with reproducible measurements: where the gain is tenfold, where it is nil and how to migrate safely.

On 20 million rows already in memory, the aggregation by category takes about 500 milliseconds in pandas 3.1.1 and about 50 in Polars 2.1.0; reading a 735 MB CSV, on the other hand, is almost a tie. Polars' advantage is not uniform: it depends on the operation, on the file format, on how much work the engine manages to skip and on how many cores it has available. Here you find the measurements, the program to repeat them and the points where the migration costs more than it returns.

Prerequisites. Python and a bit of pandas; DuckDB appears in only one example and you do not need to know it beforehand.

What is measured, and how

A performance comparison is only as good as the method behind it, so I state it in full. The figures in this article are mine and come from the listing that follows; no number is taken from articles, vendor sites or third-party benchmarks. They change if you change machine, versions or data, which is why the program prints an interval and not a single value. The conditions are these:

  • machine: AMD Ryzen 5 5600H with 12 logical threads, 30 GB of RAM, local disk, files already in the operating system cache;
  • software: Python 3.14.4, pandas 3.1.1, Polars 2.1.0, PyArrow 26.0.1, all current versions as of 2026-11-13;
  • data: 20 million synthetic rows with a fixed seed (numpy default_rng(42)), a 735 MB CSV and the same content as a 248 MB Parquet file;
  • stopwatch: 5 repetitions per task in a new Python process, reported as minimum, median and maximum;
  • memory: the peak resident memory (ru_maxrss) of the process, which includes the loaded data and not only the cost of the operation.

Two limits must be stated right away. The first repetition includes startup effects (loading of libraries and caches) that the others do not have, and you see it in the maximum, often far from the median. Moreover the data are synthetic and uniform: on real data with long strings, many columns or unbalanced keys the proportions change. Before deciding, repeat the measurements on your own files.

The test dataset

The generator writes an orders file with four columns (a text category with eight values, a decimal amount, an integer quantity, an integer key) and a table of 1 million discounts for the join. The fixed seed makes the data identical on every run, checked by comparing the output of two launches. The DataFrame is created directly in Polars and saved in two formats, because the difference between CSV and Parquet is one of the most important results. The column names and the category values are in Italian, as in the original run: categoria is the category, valore the amount, quantita the quantity and chiave the key, and the categories are groceries, home, electronics, books, sports, garden, fashion and games.

import numpy as np, polars as pl, pathlib

pathlib.Path("dati").mkdir(exist_ok=True)
rng = np.random.default_rng(42)            # fixed seed: same data on every run
n = 20_000_000
categorie = np.array(["alimentari", "casa", "elettronica", "libri", "sport", "giardino", "moda", "giochi"])

df = pl.DataFrame({
    "categoria": categorie[rng.integers(0, len(categorie), n)],
    "valore": rng.normal(100.0, 15.0, n),
    "quantita": rng.integers(1, 1000, n),
    "chiave": rng.integers(0, 1_000_000, n),
})
df.write_csv("dati/ordini.csv")
df.write_parquet("dati/ordini.parquet")

# small table for the join: 1 million keys, each with a discount band
rng2 = np.random.default_rng(7)
dim = pl.DataFrame({"chiave": np.arange(1_000_000), "sconto": rng2.integers(0, 30, 1_000_000)})
dim.write_parquet("dati/sconti.parquet")

for f in ("ordini.csv", "ordini.parquet", "sconti.parquet"):
    print(f"{f}: {pathlib.Path('dati', f).stat().st_size / 1e6:.0f} MB")
print(df.head(3))

# Output:
# ordini.csv: 735 MB
# ordini.parquet: 248 MB
# sconti.parquet: 2 MB
# shape: (3, 4)
# ┌────────────┬────────────┬──────────┬────────┐
# │ categoria  ┆ valore     ┆ quantita ┆ chiave │
# │ ---        ┆ ---        ┆ ---      ┆ ---    │
# │ str        ┆ f64        ┆ i64      ┆ i64    │
# ╞════════════╪════════════╪══════════╪════════╡
# │ alimentari ┆ 116.222483 ┆ 698      ┆ 958520 │
# │ moda       ┆ 114.125745 ┆ 756      ┆ 689173 │
# │ giardino   ┆ 86.871773  ┆ 423      ┆ 834971 │
# └────────────┴────────────┴──────────┴────────┘

The Parquet file weighs a third of the CSV (248 MB against 735 MB) because it stores the columns with a type and compresses them; it also carries the type of every column with it, while the CSV forces the reader to guess it. If you have the choice, a file that passes from one pipeline to another is better in Parquet; the CSV remains the exchange format with whoever cannot read anything else.

The four tasks

The file compiti.py ("tasks") runs one task with one engine and prints time and memory. Aggregation and join start from data already in memory, to measure only the operation; reading the CSV and reading the Parquet with a filter instead measure the whole path from disk to result. For Parquet I added a third contender, pandas_filters: pandas can pass the filter to the Parquet reader with the filters parameter, and ignoring it would make the comparison unfair to pandas.

"""One task at a time, in a new process: python compiti.py <task> <engine>"""
import resource, sys, time

compito, motore = sys.argv[1], sys.argv[2]
REPS = 5

def prepara():
    """Loads the data OUTSIDE the stopwatch, for the tasks that measure only the operation."""
    if motore == "pandas":
        import pandas as pd
        return pd.read_parquet("dati/ordini.parquet"), pd.read_parquet("dati/sconti.parquet")
    import polars as pl
    return pl.read_parquet("dati/ordini.parquet"), pl.read_parquet("dati/sconti.parquet")

def gruppi(d):
    ordini, _ = d
    if motore == "pandas":
        return ordini.groupby("categoria").agg(valore=("valore", "mean"), quantita=("quantita", "sum"))
    import polars as pl
    return ordini.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())

def join(d):
    ordini, sconti = d
    if motore == "pandas":
        return ordini.merge(sconti, on="chiave", how="inner")
    return ordini.join(sconti, on="chiave", how="inner")

def csv(_):
    if motore == "pandas":
        import pandas as pd
        return pd.read_csv("dati/ordini.csv")
    import polars as pl
    return pl.read_csv("dati/ordini.csv")

def parquet_filtro(_):
    # reads the file AND applies filter and aggregation: the whole path counts
    if motore == "pandas":
        import pandas as pd
        df = pd.read_parquet("dati/ordini.parquet")
        return df[df["quantita"] > 990].groupby("categoria")["valore"].mean()
    if motore == "pandas_filters":
        import pandas as pd
        df = pd.read_parquet("dati/ordini.parquet", filters=[("quantita", ">", 990)])
        return df.groupby("categoria")["valore"].mean()
    import polars as pl
    return (pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990)
              .group_by("categoria").agg(pl.col("valore").mean()).collect())

FUNZ = {"gruppi": gruppi, "join": join, "csv": csv, "parquet_filtro": parquet_filtro}
dati = prepara() if compito in ("gruppi", "join") else None
tempi = []
for _ in range(REPS):
    t0 = time.perf_counter()
    FUNZ[compito](dati)
    tempi.append(time.perf_counter() - t0)
tempi.sort()
mediana = tempi[len(tempi) // 2]
rss_mb = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024
print(f"{tempi[0]*1000:.0f} {mediana*1000:.0f} {tempi[-1]*1000:.0f} {rss_mb:.0f}")

Each task runs in its own process, so the memory of one does not pollute that of another. The Polars engine uses pl.scan_parquet for the case with a filter: it is the lazy read, which builds a plan and reads only the columns and rows that are needed. The driver below launches the processes and collects the results; on every run the intervals change by a few percentage points. Since it prints timings, it keeps the labels of the original run: gruppi is the aggregation, parquet_filtro the Parquet read with a filter, mediana the median and picco the peak.

import subprocess, sys

def esegui(compito, motore):
    r = subprocess.run([sys.executable, "compiti.py", compito, motore], capture_output=True, text=True)
    if r.returncode:
        return f"ERRORE: {r.stderr.strip().splitlines()[-1]}"
    lo, med, hi, rss = r.stdout.split()
    return f"min {lo:>5}  mediana {med:>5}  max {hi:>5} ms   picco {rss:>5} MB"

PROVE = [("gruppi", ["pandas", "polars"]), ("join", ["pandas", "polars"]),
         ("csv", ["pandas", "polars"]), ("parquet_filtro", ["pandas", "pandas_filters", "polars"])]
for compito, motori in PROVE:
    print(compito)
    for m in motori:
        print(f"  {m:<15} {esegui(compito, m)}")

# Output:
# gruppi
#   pandas          min   514  mediana   529  max   584 ms   picco  2254 MB
#   polars          min    47  mediana    48  max    49 ms   picco   907 MB
# join
#   pandas          min   690  mediana   742  max   964 ms   picco  2401 MB
#   polars          min   367  mediana   530  max   651 ms   picco  2210 MB
# csv
#   pandas          min   515  mediana   569  max   857 ms   picco  2047 MB
#   polars          min   407  mediana   444  max   820 ms   picco  1609 MB
# parquet_filtro
#   pandas          min   236  mediana   290  max   630 ms   picco  2469 MB
#   pandas_filters  min   189  mediana   225  max   532 ms   picco   781 MB
#   polars          min    39  mediana    40  max   171 ms   picco   122 MB

How to read the table

Aggregation is where Polars pulls ahead the most: the pandas median is about ten times that of Polars, in all the series I ran. Behind it there is mainly parallelism, measured in the next section, and in part a columnar in-memory representation following the Arrow format. The join has a more modest advantage, around 1.4-2.4 times in my series: the discount table has 1 million keys and the work is dominated by random memory access, which no engine eliminates.

Reading the CSV is almost a tie, and here the classic story "pandas reads on one core" does not hold: the pandas 3.1.1 documentation says the C engine reads sufficiently large files in parallel, and the measurements confirm it (medians between 0.5 and 0.6 seconds for both, the two intervals overlap). The clearest case is Parquet with a filter: Polars reads only three columns out of four, discards the rows already in the scan and never materializes the whole table, so it ends up around 40-50 milliseconds with a peak of about 125 MB. Pandas without filters loads everything: over 2 GB of peak.

The most useful figure for whoever decides is the one on the right: pandas with filters cuts the memory peak from about 2.4 GB to about 0.8 GB and the time by a third or more (in my series from 1.6 to 3 times), without changing library. A substantial part of the "Polars advantage" on Parquet is therefore an advantage of how you read the file, and it can partly be obtained while staying in pandas. The rest (aggregation, join, memory in scans) is a real advantage of the engine.

How much parallelism is worth

The question the comparison alone does not settle is: does the advantage on aggregation come from the algorithm or from the cores? You see it by measuring two things together, real time and CPU time, while limiting the number of Polars threads with the POLARS_MAX_THREADS environment variable, which the documentation indicates as the way to set the pool size before the process starts. Each measurement runs in a new process, because after startup the pool cannot be changed. This listing too prints timings, so its labels stay as in the original run: ms reali is real milliseconds, ms di CPU CPU milliseconds and thread usati the threads used.

import os, subprocess, sys

CODICE = """
import time, polars as pl
df = pl.read_parquet("dati/ordini.parquet")
q = lambda: df.group_by("categoria").agg(pl.col("valore").mean(), pl.col("quantita").sum())
q()                                   # warm-up
t, c = [], []
for _ in range(5):
    w, p = time.perf_counter(), time.process_time()
    q()
    t.append(time.perf_counter() - w); c.append(time.process_time() - p)
print(f"{min(t)*1000:.0f} ms reali, {min(c)*1000:.0f} ms di CPU, thread usati: {pl.thread_pool_size()}")
"""
for n in (1, 2, 4, 12):
    env = dict(os.environ, POLARS_MAX_THREADS=str(n))
    r = subprocess.run([sys.executable, "-c", CODICE], env=env, capture_output=True, text=True)
    print(f"POLARS_MAX_THREADS={n:>2}: {r.stdout.strip() or r.stderr.strip().splitlines()[-1]}")

# Output:
# POLARS_MAX_THREADS= 1: 221 ms reali, 221 ms di CPU, thread usati: 1
# POLARS_MAX_THREADS= 2: 112 ms reali, 222 ms di CPU, thread usati: 2
# POLARS_MAX_THREADS= 4: 61 ms reali, 237 ms di CPU, thread usati: 4
# POLARS_MAX_THREADS=12: 45 ms reali, 446 ms di CPU, thread usati: 12

With one thread Polars takes about 210-220 ms, against about 500 ms for pandas: a factor of 2.3 that comes from the implementation. Then real time drops almost linearly at 2 and 4 threads (about 115 ms and 58-68 ms) while CPU time stays the same: the work is the same, divided among more cores. At 12 threads the gain flattens (about 42-47 ms) and CPU time doubles, a sign of extra work to coordinate the threads. On a 2 vCPU machine, like many cheap virtual machines, the aggregation would therefore be closer to 4 times than to 10.

The lazy plan and what it hides

The Parquet example was fast because Polars does not execute the rows as you write them: it builds a plan and optimizes it at the moment of collect(). The following block shows the plan of the same query: the filter on quantity was pushed inside the scan (SELECTION) and only 3 columns out of 4 are read (PROJECT 3/4 COLUMNS).

import polars as pl

lf = pl.scan_parquet("dati/ordini.parquet").filter(pl.col("quantita") > 990) \
       .group_by("categoria").agg(pl.col("valore").mean().alias("average"))

print(type(lf).__name__)                 # no computation has started yet
print(lf.explain())                      # the optimized plan
result = lf.collect()
print(type(result).__name__, result.shape)

# Output:
# LazyFrame
# AGGREGATE[maintain_order: false]
#   [col("valore").mean().alias("average")] BY [col("categoria")]
#   FROM
#   simple π 2/2 ["categoria", "valore"]
#     Parquet SCAN [dati/ordini.parquet]
#     PROJECT 3/4 COLUMNS
#     SELECTION: col("quantita") > 990
#     ESTIMATED ROWS: 20000000
# DataFrame (8, 2)

The classic mistake is forgetting collect() and ending up with a LazyFrame instead of the data. Since 2.0 there is also a novelty that can change results without warning you: the upgrade page of the documentation explains that with collect() the engine="auto" option now uses the streaming engine for lazy queries, and that this engine does not guarantee row order in group_by, in joins and in other operations. If your code depends on an order that nobody ever requested, sort explicitly or use the order-preserving options where they exist.

Migrating without changing the results

The first guarantee of a migration is that the same data give the same numbers. The following test runs four operations in pandas and in Polars on the same million rows and compares the results with assert_frame_equal, sorting the rows before the comparison because, as seen, the order is not guaranteed. I ignore the data type (check_dtype=False), because pandas and Polars do not represent integers and strings in the same way.

import pandas as pd
import polars as pl

pdf = pd.read_parquet("dati/ordini.parquet").head(1_000_000)
plf = pl.read_parquet("dati/ordini.parquet").head(1_000_000)

def ordina(df):                      # comparison independent of row order
    return df.sort_values(list(df.columns)).reset_index(drop=True)

coppie = {
    "filter":      (pdf[pdf["quantita"] > 990],
                    plf.filter(pl.col("quantita") > 990).to_pandas()),
    "selection":   (pdf[["categoria", "valore"]],
                    plf.select("categoria", "valore").to_pandas()),
    "aggregation": (pdf.groupby("categoria", as_index=False)["quantita"].sum(),
                    plf.group_by("categoria").agg(pl.col("quantita").sum()).to_pandas()),
    "new column":  (pdf.assign(total=pdf["valore"] * pdf["quantita"]),
                    plf.with_columns((pl.col("valore") * pl.col("quantita")).alias("total")).to_pandas()),
}
for nome, (a, b) in coppie.items():
    pd.testing.assert_frame_equal(ordina(a), ordina(b), check_dtype=False)
    print(f"{nome:<14} identical ({len(a)} rows)")

# Output:
# filter         identical (9154 rows)
# selection      identical (1000000 rows)
# aggregation    identical (8 rows)
# new column     identical (1000000 rows)

The table collects the correspondences that the test verified, plus the lazy read that has no direct equivalent in pandas:

OperationpandasPolars
Filterdf[df["x"] > 5]df.filter(pl.col("x") > 5)
Selectiondf[["a", "b"]]df.select("a", "b")
Aggregationdf.groupby("c")["q"].sum()df.group_by("c").agg(pl.col("q").sum())
New columndf.assign(t=df["v"] * df["q"])df.with_columns((pl.col("v") * pl.col("q")).alias("t"))
Joina.merge(b, on="k")a.join(b, on="k")
Lazy readread_parquet(..., filters=...)pl.scan_parquet(...).filter(...).collect()

The biggest conceptual difference is not in the syntax but in the index: Polars has no row indexes and no MultiIndex, and every row is identified by its position, as the migration guide in the official documentation says. If your pandas code uses set_index, loc with labels or unstack, the rewrite is not mechanical. Another trap: the name groupby used by many old tutorials no longer exists, and is now group_by.

import polars as pl

df = pl.DataFrame({"categoria": ["a", "b", "a"], "valore": [1, 2, 3]})
try:
    df.groupby("categoria").agg(pl.col("valore").sum())      # name used by the old tutorials
except AttributeError as e:
    print("AttributeError:", e)
print(df.group_by("categoria").agg(pl.col("valore").sum()).sort("categoria").to_dict(as_series=False))

# Output:
# AttributeError: 'DataFrame' object has no attribute 'groupby'
# {'categoria': ['a', 'b'], 'valore': [4, 2]}

NaN and null: where results diverge

Missing values are the most concrete cause of different results after the migration. Pandas uses NaN (and sometimes None) and, in the default types, turns an integer column containing a hole into a decimal one. In Polars the missing value is always null, the integer column stays integer, and NaN is a decimal value like any other, which does not count as missing. The listing compares the two.

import numpy as np
import pandas as pd
import polars as pl

pdf = pd.DataFrame({"x": [1.0, np.nan, 3.0], "n": [1, None, 3]})
print(pdf.dtypes.to_dict())              # pandas: the integer with a hole becomes float
print("pandas, mean of x:", pdf["x"].mean())

native = pl.DataFrame({"x": [1.0, float("nan"), None], "n": [1, None, 3]})
print(native.schema)                     # Polars: the integer stays integer
print("Polars, nan and null are two different things:")
print(native.select(
    nan=pl.col("x").is_nan(), null=pl.col("x").is_null()).to_dict(as_series=False))
print("Polars, mean of x:", native["x"].mean())

# the conversion from pandas turns NaN into null (parameter nan_to_null)
print("from pandas:", pl.from_pandas(pdf)["x"].null_count(), "null out of", len(pdf))

# Output:
# {'x': dtype('float64'), 'n': dtype('float64')}
# pandas, mean of x: 2.0
# Schema({'x': Float64, 'n': Int64})
# Polars, nan and null are two different things:
# {'nan': [False, True, None], 'null': [False, False, True]}
# Polars, mean of x: nan
# from pandas: 1 null out of 3

The pandas mean ignores the NaN (2.0), while in Polars the column with NaN and null gives nan: the NaN contaminates the computation and the null is ignored. The pl.from_pandas conversion turns NaN into null, so data passed that way behaves as in pandas, while data read from a file that already contains NaN does not. Always add a test on your dirtiest data.

Polars and DuckDB in the same program

You do not have to choose a single tool. DuckDB can read a Polars DataFrame present in the program as if it were a table, citing it by variable name, and return the result as a Polars DataFrame with the .pl() method. It is handy when a transformation is better written in SQL, and the data handover is columnar, through Arrow. The complete composition of a pipeline is in the article DuckDB and Polars: a lean pipeline in Python, while the choice between DuckDB and Spark is in DuckDB in production.

import duckdb
import polars as pl

df = pl.read_parquet("dati/ordini.parquet")
# DuckDB reads the Python variable `df` directly (replacement scan) and returns a Polars DataFrame
top = duckdb.sql("""
    SELECT categoria, count(*) AS row_count, round(avg(valore), 2) AS average
    FROM df GROUP BY categoria ORDER BY row_count DESC LIMIT 3
""").pl()
print(type(top).__module__.split(".")[0], top.shape)
print(top)

# Output:
# polars (3, 3)
# shape: (3, 3)
# ┌───────────┬───────────┬─────────┐
# │ categoria ┆ row_count ┆ average │
# │ ---       ┆ ---       ┆ ---     │
# │ str       ┆ i64       ┆ f64     │
# ╞═══════════╪═══════════╪═════════╡
# │ libri     ┆ 2501822   ┆ 99.99   │
# │ casa      ┆ 2501488   ┆ 100.0   │
# │ sport     ┆ 2501032   ┆ 100.02  │
# └───────────┴───────────┴─────────┘

Here duckdb.sql(...) finds the variable df in the Python scope (the so-called replacement scan). The DuckDB documentation specifies that a DataFrame is converted in full and filtered afterwards, while a LazyFrame receives the column selection and the translatable filters: with large data, pass a LazyFrame. If you rename the variable, the query stops working with a nonexistent-table error. For production use, prefer to register the DataFrame explicitly with the name you want.

When migrating pays off, with the numbers

A migration costs days of development and testing; the benefit is machine time, memory and, sometimes, the possibility of using a smaller machine. The listing computes how long it takes to recover the cost with the compute savings alone. The values are my own examples and are declared as such in the code: replace them with yours, and above all with the times measured on your job.

# EXAMPLE values: replace them with yours. None is a measurement.
seconds_pandas = 300        # duration of the job today, per run
seconds_polars = 60         # duration after the migration (to be measured on YOUR code)
runs_per_day = 24
machine_cost_per_hour = 0.50   # euro/hour of the machine the job runs on
dev_days = 6
dev_day_cost = 400    # euro

savings_per_day = (seconds_pandas - seconds_polars) * runs_per_day / 3600 * machine_cost_per_hour
migration_cost = dev_days * dev_day_cost
print(f"compute savings per day: {savings_per_day:.2f} euro")
print(f"migration cost: {migration_cost} euro")
print(f"break-even on compute alone after: {migration_cost / savings_per_day:.0f} days")

# Output:
# compute savings per day: 0.80 euro
# migration cost: 2400 euro
# break-even on compute alone after: 3000 days

The result is unpleasant and instructive: even bringing a job from 300 to 60 seconds, 24 times a day, the compute saving is less than one euro a day, and break-even comes after years. If the only reason for the migration is the cost of the machine, it often does not pay off. It pays off when the job no longer fits in the machine's memory, when it exceeds the nightly window available or when the analysts' waiting time is the real cost.

The practical rule I draw from it has two halves. Stay on pandas if the data are small, if the code depends on indexes or on libraries that expect a pandas DataFrame, or if the team has no time for the switch; move to Polars when a measurement on your workload shows a time or a memory use you can no longer accept. The two coexist well: to_pandas() and pl.from_pandas() are designed for this.

What you can do now

You can set up an honest comparison between pandas and Polars: data with a fixed seed, one process per trial, minimum-median-maximum and memory peak. You can recognize where the advantage is real (aggregation, Parquet scans) and where it is modest or nil (reading large CSVs), check that a migration does not change the results, and do the math before rewriting. For the formats to put these files in, move on to Iceberg, Delta Lake and Hudi; to version the results, to lakeFS, where you will also find the license change to know about.

Frequently asked questions

Is Polars always faster than pandas?

No. In my measurements on 20 million rows it wins clearly on aggregation and on Parquet reads with a filter, wins slightly on the join and ties on reading a large CSV. With small data the difference is negligible compared with Python's startup time.

Can I use Polars and pandas in the same project?

Yes. DataFrame.to_pandas() and pl.from_pandas() convert in both directions, and this article's equivalence test uses them. Watch out for missing values: the conversion from pandas turns NaN into null.

Why does the same query return rows in a different order?

Since version 2.0 the streaming engine is the default for lazy queries and does not guarantee row order in group_by and in joins. If you need an order, add an explicit sort to the result.

Do the licenses allow commercial use?

Polars is distributed under the MIT license, as the project declares on its site; pandas under the BSD-3-Clause license according to the metadata on PyPI. The Polars team also sells a separate managed platform, which you do not need in order to use the library.

Sources

All the listings were run with Python 3.14.4, pandas 3.1.1 and Polars 2.1.0. Those with a fixed output were launched twice with identical results; the timing table comes from a single run and changes from one to the next, while the cost calculation uses example values. The listings that print timings keep the labels of the original run, in Italian, and were not rerun for the English edition.

Try These Tools

Free developer tools related to this topic.

Commenti

Caricamento commenti...

Sign in to comment

New articles and tools on Telegram too

The Telegram channel flags the site's new articles and tools.

Did you like this article?

Explore other content on the blog or discover my projects