DEV Community: authur

Pressure Advance Calibration in Klipper: The Tuning Tower, the Math, and How to Read It

authur — Wed, 03 Jun 2026 18:24:48 +0000

If your prints have bulging corners, blobby seams, or thin gaps right after a fast move, you don't have an extrusion problem — you have a pressure problem. The fix is pressure advance (Klipper) or linear advance (Marlin). This guide covers what it actually does, how to calibrate it with a tuning tower, and the small bit of math that turns the test into a final number.

What pressure advance actually does

When the nozzle moves fast, pressure builds up in the melt zone. When it slows for a corner, that pressure keeps pushing plastic out for a moment — so the corner bulges. When it speeds back up, there's a brief under-extrusion gap. The extruder simply can't start and stop the flow instantly.

Pressure advance tells the firmware to advance (or relax) the extruder ahead of speed changes to cancel that lag. It does not change how much filament is extruded overall — that's what rotation_distance (Klipper) or E-steps (Marlin) and flow rate control. So calibrate those first; pressure advance is the layer on top.

The tuning tower method

Klipper has a neat trick: the TUNING_TOWER command sweeps a parameter as the print gets taller, so a single object shows every value at once.

Slice a tall test model (the notched-cube PA test from the Klipper docs is ideal).
Start the print, then run this in the console:

   TUNING_TOWER COMMAND=SET_PRESSURE_ADVANCE PARAMETER=ADVANCE START=0 FACTOR=.005

That starts pressure_advance at 0 and adds 0.005 for every 1 mm of height.
Let it print, then look for the height where corners are sharpest — no bulge before them, no gap after.

The math: turn a height into a value

The value at any height is just:

pressure_advance = START + measured_height × FACTOR

So if you used START=0 and FACTOR=0.005 and the cleanest band is at 35 mm:

0 + 35 × 0.005 = 0.175

Your pressure_advance is 0.175. If you'd rather not do it by hand (or want a suggested FACTOR for a tighter second tower when the best band lands near the top or bottom), this free browser tool does exactly this: Pressure Advance calculator.

Apply the value in printer.cfg, then RESTART and reprint the test to confirm:

[extruder]
pressure_advance: 0.175

Reading the tower (the part people get wrong)

You're not looking for "smooth walls" — you're looking at corners and direction changes. Too little PA: corners bulge outward. Too much: corners get rounded and under-filled, and you see gaps. The sweet spot is the lowest band where corners are crisp and consistent. Don't judge the seam or the first few layers — they're not representative.

If the best result is at the very top or bottom of the tower, your range was off. Widen it, or use the suggested-factor approach to center a tighter second tower.

Direct drive vs Bowden

The right value depends almost entirely on how far the filament has to travel:

Direct drive: small, often 0.02–0.08.
Bowden: much larger because of the tube, often 0.3–1.0.

Tube length, extruder gearing, temperature, and even the filament shift it, so never just copy someone else's number — run the tower.

Marlin users: linear advance

Same idea, different name and command. Marlin calls it linear advance, set with M900 K<value> and saved with M500. If you run a height-based tower, the formula above applies directly. If you print the classic labeled K-factor pattern instead, just read K off the cleanest line.

M900 K0.05
M500

Order of operations

Pressure advance only makes sense once extrusion is already accurate:

rotation_distance / E-steps — correct length of filament fed.
Flow rate — correct amount in the wall.
Pressure advance — correct pressure at corners. ← you are here.
Retraction — kill stringing on travel moves.

Do it in that order, or you'll be chasing one error with another tool. If you want the math done for you, there are small browser calculators for rotation_distance, flow rate, and retraction.

TL;DR

Bulging corners = pressure, not extrusion.
Run TUNING_TOWER COMMAND=SET_PRESSURE_ADVANCE PARAMETER=ADVANCE START=0 FACTOR=.005.
pressure_advance = START + height × FACTOR (e.g. 35 mm → 0.175).
Direct drive ≈ 0.02–0.08, Bowden ≈ 0.3–1.0 — but always test.
Calibrate extruder + flow first, retraction after.

Happy tuning — sharp corners await.

Klipper rotation_distance Calibration: A Step-by-Step Guide (With the Math)

authur — Sun, 31 May 2026 19:58:47 +0000

If you moved to Klipper from Marlin, the first thing that trips people up is that
there are no E-steps. Klipper describes the extruder with a single value called
rotation_distance — how many millimeters of filament move per full rotation of the
extruder motor. Get it wrong and every print is silently over- or under-extruded, no
matter how dialed-in your slicer is.

This guide walks through calibrating it properly, including the formula so you
understand why it works rather than just copying numbers.

What rotation_distance actually means

In your printer.cfg:

[extruder]
rotation_distance: 7.5

That 7.5 means: one full turn of the extruder stepper should push 7.5 mm of
filament. Klipper computes the step timing from this value plus your microsteps
and full_steps_per_rotation, so you never touch steps/mm directly the way Marlin
does. Calibrating the extruder = correcting this one number.

The calibration method: measure 100 mm of extrusion

This is the same "mark and measure" routine every firmware uses; only the final
math differs.

Heat the hotend to the normal printing temperature for your loaded filament, so it extrudes freely without skipping.
Mark the filament at a fixed reference — e.g. exactly 120 mm above the extruder inlet — with a marker or piece of tape.
Command a slow 100 mm extrusion. Use relative mode so you don't have to track absolute position:

   M83
   G1 E100 F100

Keep it slow (F100 = 100 mm/min). Fast extrusion skips steps and ruins the test.

Measure what actually moved. Measure from your reference point again. If you marked at 120 mm and now read 25 mm, the extruder pulled in 95 mm — it under-extruded by 5 mm.

The formula

new rotation_distance = current rotation_distance × (actual extrusion / commanded extrusion)

Worked example: current rotation_distance is 7.5, you commanded 100 mm, and
only 95 mm actually fed:

7.5 × (95 / 100) = 7.125

So your corrected value is 7.125.

Watch the direction — this is the #1 gotcha for Marlin migrants.
With Marlin E-steps, under-extrusion means you raise steps/mm. With Klipper
rotation_distance, under-extrusion means you lower the value. They're inverse
quantities (mm-per-rotation vs steps-per-mm), so the correction goes the opposite
way. If you mentally apply the E-steps direction here, you'll double your error.

If you'd rather not do this by hand (or want to sanity-check the direction), this
free browser tool does exactly this calculation and also converts an old Marlin
steps/mm value into an equivalent Klipper rotation_distance:
Klipper rotation_distance calculator.
Coming from Marlin and want to see the E-steps side too? There's a matching
E-steps calculator.

Apply the value

Edit printer.cfg manually — Klipper doesn't have a "save E-steps" G-code like
Marlin's M500 for this:

[extruder]
rotation_distance: 7.125

Then RESTART (or FIRMWARE_RESTART if you changed pins) and re-run the 100 mm
test. If the first correction was large, expect to iterate once more — measurement
error, filament slip, and a slightly cold nozzle all add noise. You're aiming for
the measured value to land within ~0.5 mm of 100.

Reference starting points (for non-extruder axes)

The same rotation_distance concept governs your motion axes, and for those you can
calculate the starting value instead of measuring:

Belt axis: rotation_distance = belt_pitch × pulley_teeth (e.g. 2 mm GT2 belt × 20-tooth pulley = 40)
Leadscrew (Z): rotation_distance = screw_pitch × number_of_starts (e.g. T8 with 4 starts at 2 mm pitch = 8)

These are exact for motion axes; the extruder is the one that needs the
measure-and-correct loop above because of filament grip variability.

What to calibrate next

Getting rotation_distance right only guarantees the correct length of filament
is fed. It does not fix how much plastic ends up in the wall after squish and
pressure. Once the extruder is accurate:

Flow rate / extrusion multiplier — print a single-wall cube and measure the wall with calipers. Tune it per filament in the slicer, not in firmware. A flow rate calculator handles the new flow = current × expected_wall / measured_wall math.
Pressure advance — for sharp corners and consistent extrusion at speed.
Volumetric flow ceiling — make sure fast prints aren't outrunning your hotend's melt rate.

Calibrate in that order. If you tune flow before the extruder, the flow
compensation just masks a wrong rotation_distance, and you'll be chasing ghosts.

TL;DR

Klipper uses rotation_distance, not E-steps.
Measure a slow 100 mm extrusion, then new = current × actual / commanded.
Under-extrusion → lower the value (opposite of Marlin).
Edit printer.cfg, RESTART, re-measure, iterate.
Then do flow → pressure advance → volumetric flow.

Happy printing — and may your extrusion multipliers be ever accurate.

umask vs chmod: why your new files keep getting the 'wrong' permissions

authur — Sun, 31 May 2026 07:08:37 +0000

If you've ever run chmod to fix a file's permissions, created a new file five minutes later, and found it back at the "wrong" mode — you've met umask. They look related, but they do different jobs, and confusing them causes a surprising amount of "why is this 644 again?" frustration.

Here's the short version.

chmod changes permissions on files that already exist

chmod is reactive. It takes a file (or directory) that exists right now and sets its mode.

chmod 640 secret.conf      # rw-r----- on this one file
chmod u+x deploy.sh        # add execute for the owner

That's it. It does nothing for the next file you create.

umask sets the default for files you haven't created yet

umask is proactive. It's a mask that gets subtracted (bitwise) from the base permissions the OS hands out when something new is created:

New files start from 666 (rw-rw-rw-)
New directories start from 777 (rwxrwxrwx)

The kernel then strips whatever bits your umask names.

umask          # show current mask, often 0022
umask 027      # set a stricter mask for this shell

The relationship in one line

final permission = base (666 file / 777 dir) AND (NOT umask)

So with the common umask 022:

Created	Base	umask	Result
File	666	022	644 (`rw-r--r--`)
Directory	777	022	755 (`rwxr-xr-x`)

This is why a fresh file is 644 even though you never ran chmod — the umask did it for you.

Common umask values worth memorizing

umask	New files	New dirs	Use case
`022`	644	755	Default on most distros; world-readable
`027`	640	750	Group-friendly, hidden from "others"
`077`	600	700	Private — only the owner can touch it

A quick gut check: umask 077 is the one you want for SSH keys, secrets, and anything in a shared box.

When to reach for which

Need to fix this file, now? → chmod
Tired of fixing the same default over and over? → set umask (in your ~/.bashrc, a systemd unit's UMask=, or /etc/login.defs for system-wide)

A trap worth knowing: umask only ever removes bits. It can't grant execute on a file the way chmod +x does — the base mode for files is 666, which has no execute bits to begin with. That's why new scripts always need an explicit chmod +x.

Try it without doing octal math in your head

If you'd rather not compute 666 AND NOT 022 by hand, I keep two small client-side tools bookmarked (everything runs in the browser, nothing is uploaded):

An interactive umask calculator — type a mask, see the resulting file/dir modes instantly.
A longer write-up: umask vs chmod, explained with a full cheat sheet and FAQ.

TL;DR: chmod edits one existing file. umask is the default filter applied to everything you create next. Fix the present with chmod; fix the future with umask.

What umask do you run on your servers? I'm curious how many people switched to 027/077 after a close call.

Why umask 022 creates 755 folders and 644 files

authur — Mon, 18 May 2026 13:23:49 +0000

If you have ever wondered why umask 022 creates directories like 755 but files like 644, the short answer is:

directories start from 777
regular files usually start from 666
umask subtracts permissions from those defaults

So 022 does not mean "set permissions to 022". It means "remove these permission bits from the default mode".

The common example

For directories:

777 - 022 = 755

For regular files:

666 - 022 = 644

That is why a newly created folder often becomes:

drwxr-xr-x

And a newly created file often becomes:

-rw-r--r--

Why files do not start from 777

Directories need the execute bit so users can enter and traverse them.

Regular files usually do not start as executable. That is why the default starting point for many newly created files is 666, not 777.

So this is expected:

umask 022 -> folders 755
umask 022 -> files 644

More examples

umask 002 -> folders 775, files 664
umask 027 -> folders 750, files 640
umask 077 -> folders 700, files 600

002 is common when a shared group needs write access.

027 is stricter: group can read and enter directories, but others get no access.

077 is private: only the owner gets access.

chmod vs umask

A lot of confusion comes from mixing up chmod and umask.

chmod changes permissions on existing files or directories.

umask controls the default permissions for new files and directories.

So if a file already exists, changing your umask will not change that file. You would use chmod for that.

If new files are being created with the wrong permissions, then checking the current umask makes sense.

Quick checklist

When debugging a permissions problem, check these in order:

What user is creating the file?
What group owns the parent directory?
What is the current umask?
Is the filesystem a normal Linux filesystem, or something mounted with options like uid, gid, umask, fmask, or dmask?
Are you trying to fix an existing file, or the defaults for future files?

That last question usually tells you whether you need chmod or umask.

I made a small browser-local calculator for this because I kept checking the same examples repeatedly:

https://webutilslab.com/umask-calculator/?ref=devto

It runs in the browser and is mostly useful for quickly verifying cases like 022, 027, and 077.