Analyze kerning quality across all masters.

RECIPE: For kerning from scratch, call get_recipe("kerning_from_scratch") first — it covers group assignment, critical pairs, and verification.

Checks for:

• Cross-master missing pairs (pair in some masters but not all — causes interpolation jumps)

• Cross-master sign changes (positive in one master, negative in another)

• Outlier values (extreme kerning > 40% of UPM)

• Redundant exceptions (glyph-level overrides that match group value — can be removed)

• Group orphans (Letter glyphs missing kerning group assignments)

Returns a formatted markdown report without modifying glyph colors. When mark_glyphs=True, marks cross-master issues red and warnings yellow.

Args: master_id: Optional master ID (cross-master checks always run across all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Analyze and assign kerning groups to all glyphs.

RECIPE: For a complete kerning workflow (groups → pairs → verification), call get_recipe("kerning_from_scratch") first.

Assigns correct groups to all glyphs, overwriting any existing values. Uses a five-tier resolution strategy:

1. Dictionary lookup for ~80 base glyphs (A-Z, a-z, figures, punctuation)

2. Dot-suffix stripping (a.ss01 → a)

3. Component inheritance for accented/composite glyphs (Aacute → A)

4. Unicode decomposition fallback

5. Contour analysis fallback (ray-casting edge detection)

Group names follow professional conventions (key glyph = group name):

• UC left: H (straight stem), O (round), A (diagonal), V, T, S, etc.

• UC right: H (straight), O (round), D (half-round), E (horizontal), etc.

• LC left: h (straight), o (round), v (diagonal), f, etc.

• LC right: h (straight), n (arch), o (round), etc.

• Figures: each gets its own group (shapes too varied)

Does not modify glyph colors by default. Set mark_glyphs=True only when the user explicitly asks to mark applied or proposed group changes.

Args: glyph_names: Optional list of glyph names (default: all Letter/Number/Punctuation glyphs) apply: If True (default), assign groups. If False, dry run only. overwrite: If True (default), overwrite existing groups. If False, only assign to empty slots. mark_glyphs: Color affected glyphs only when explicitly requested.

Analyze spacing quality across all masters.

RECIPE: For systematic spacing work, call get_recipe("spacing_workflow") first — it follows Cheng/Briem/Ruder methodology step by step.

Measures sidebearings and white space margins using scanline ray-casting, then checks for consistency issues:

• Sidebearing group consistency (n-group: h,i,k,l,m,n,p,r should match; o-group: c,d,e,g,o,q)

• Tracy/Smith per-glyph sidebearing rules (from "Designing Type" by Karen Cheng)

• Side-type ordering (straight SB > round SB > diagonal SB)

• Symmetric glyph check (o, O, H, I should have LSB ≈ RSB)

• Reference ratios (n LSB / o LSB — optimal ~1.5x, acceptable 1.2–2.0)

• Counter-based validation (n LSB should be 25–50% of n counter width)

• Word space check (space width ≈ ¼ em ≈ width of i)

• Cross-master spacing drift (spacing ratios should be maintained)

Does not modify glyph colors by default. When mark_glyphs=True, marks significant inconsistencies red, minor deviations yellow, and passes green.

Args: master_id: Optional master ID (empty = all masters) glyph_names: Optional list of glyphs (empty = all Letter glyphs) mark_glyphs: Color glyphs by verdict only when explicitly requested

Full font color audit — analyzes ALL letter glyphs grouped by category.

RECIPE: For a full consistency audit, follow get_recipe("audit_consistency").

Groups glyphs into uppercase, lowercase, and figures, then evaluates each against expected density ratios from industry patterns.

If master_id is omitted, analyzes ALL masters with worst-verdict-wins for glyph colors in GlyphsApp.

Does not modify glyph colors by default. Set mark_glyphs=True only when the user explicitly asks to mark results in GlyphsApp.

The lowercase-to-uppercase density ratio is typically 1.10-1.16 in professional fonts.

This is the comprehensive "is my font's color even?" check. Use this before final production to catch any weight inconsistencies.

Args: master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Auto-kern glyph pairs using optical gap analysis (MB LetterKerner algorithm).

Measures the optical white area between each glyph pair using horizontal ray-casting, weighted by a trapezoidal function (full weight at baseline–xHeight, tapered in descender/ascender zones), then solves for the kern value that makes each pair's gap area match a calibration reference.

Auto-calibrates from nn (lowercase) and HH (uppercase) if no area is given.

Recommended workflow:

1. Finalize spacing first (kerning can't fix bad spacing)

2. Assign kerning groups: analyze_kerning_groups(apply=True)

3. Preview: auto_kern(pairs="critical", dry_run=True)

4. Apply critical: auto_kern(pairs="critical")

5. Expand: auto_kern(pairs="auto") — all group combinations

6. Verify: analyze_kerning()

Args: pairs: Pair selection mode: "critical" — ~75 essential pairs (AV, AT, To, Va, etc.) "auto" — generate representative pairs per kerning group combination "explicit" — use pairs_list pairs_list: Explicit pairs when pairs="explicit", e.g. [["A","V"],["T","o"]] area: Target gap area in units². None = auto-calibrate from nn/HH. step: Vertical sampling interval (default 5u, smaller = more precise) depth: Max probe depth per side (default 200u) factor: Optical correction factor (default 1.25, matches HT LetterSpacer) rounding: Round kern values to multiples of this (default 5) threshold: Skip kern values with abs < threshold (default 3) use_groups: Use group kerning keys (default True, strongly recommended) overwrite: Overwrite existing kerning (default False) dry_run: Preview only, don't apply (default False) master_id: Process only this master (empty = all masters)

Check master compatibility across all glyphs in the font.

RECIPE: For a complete pre-export check, call get_recipe("master_compatibility") first — it includes metrics interpolation and alignment zone verification.

Compares layers across masters for each glyph, checking:

• Path count, node count, node types, path directions

• Path order (spatial position must match across masters)

• Starting node positions

• Component count and names

• Anchor names

Does not modify glyph colors by default. When mark_glyphs=True, marks:

• Red (0) = incompatible (structural mismatch between masters)

• Orange (1) = empty or missing drawing in one or more masters

• Green (4) = fully compatible

Args: glyph_names: Optional list of glyphs to check (default: all glyphs) mark_glyphs: Color glyphs by verdict only when explicitly requested

Check diagonal stroke weight consistency and ratio to vertical stems.

Measures perpendicular thickness of diagonal strokes (V, A, W, X, Y, Z, v, w, x, y, z, k, M, N) and checks:

1. Related diagonal groups are consistent (V≈A≈W, v≈w≈y, etc.)

2. Diagonal/straight ratio within professional range (typically 85-100%)

If no glyph_names provided, checks all diagonal glyphs. If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks inconsistencies red, ratio warnings yellow, and passing glyphs green.

Args: glyph_names: Optional list of glyphs to check master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Screen one proposed typeface family name for known collisions.

Queries the public Fontdata Namecheck API and returns exact, close, and partial match counts, trademark information, a review status, timestamp, and a link to the full result. This is collision screening, not legal clearance: a name that is not found is not guaranteed to be available.

Args: name: Proposed typeface family name to check.

Check font coverage against Google Fonts glyphset definitions.

With no arguments, lists all available glyphsets. With a glyphset name, reports which glyphs are present and which are missing.

Use add_missing=True to create empty glyphs for all missing characters, ready for the designer to draw.

Args: glyphset: Glyphset name or shortcut. Examples: "GF_Latin_Core" — required for Google Fonts onboarding (324 glyphs) "GF_Latin_Plus" — extended Latin (141 additional glyphs) "latin_core" — shortcut for GF_Latin_Core "latin_plus" — shortcut for GF_Latin_Core + GF_Latin_Plus (465 total) "latin_all" — shortcut for Core + Plus + Beyond (598 total) "cyrillic_core", "greek_core", "arabic_core" — other scripts Empty string — list all available glyphsets and shortcuts add_missing: If True, create empty glyphs for all missing characters in the font. New glyphs are marked with blue color label.

Check junction thinning consistency across related glyphs.

Measures how stems thin at arch/bowl junctions (n, m, b, d, p, q, etc.) by sweeping horizontal rays at multiple heights. Reports thinning % (100% = no thinning, 80% = stem thins to 80% at junction).

Checks consistency within groups (n≈m, b≈p, d≈q). Does NOT flag based on absolute values — thinning is design-specific. Only flags inconsistencies between related forms.

If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks inconsistencies red and passing glyphs green.

Args: glyph_names: Optional list of glyphs to check (default: n,h,m,u,a,b,d,p,q) master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Check the open font's language support with Shaperglot.

Exports a temporary binary from the active Glyphs font, then runs Shaperglot against it. With no languages provided, returns the languages whose score meets support_threshold. With languages, returns per-language scores plus warnings/failures.

Args: languages: Optional language IDs or names, e.g. ["en_Latn", "Turkish", "Navajo"] instance_name: Optional Glyphs instance name to export. Empty = first exportable instance. export_format: "otf" (default) or "ttf" support_threshold: Minimum score to count a language as supported in report mode max_results: Max languages to show in report mode

Check overshoot values for round and pointed forms.

RECIPE: For a pre-export check, follow get_recipe("master_compatibility").

Round forms (O, o, C, S, etc.) should overshoot baseline and zone top by ~1-2% of zone height. Pointed forms (A, V, W) need MORE overshoot than rounds to appear optically aligned.

If no glyph_names provided, checks all known overshoot-sensitive glyphs in the font (O,C,D,G,Q,S,U,A,V,W,M,N,o,c,e,s,b,d,p,q,g,a,u,v,w,y + figures).

If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks missing/excessive overshoots red and passing glyphs green.

Args: glyph_names: Optional list of glyphs to check (default: all overshoot glyphs) master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Check punctuation consistency: mirrored pairs, width matches, and ratio checks.

Based on industry patterns across professional fonts. Checks:

Width matches (should be identical/similar):

• Mirrored pairs: parenleft/parenright, bracketleft/bracketright, braceleft/braceright, guillemotleft/guillemotright (high severity — must match)

• Related pairs: period/comma, colon/semicolon, quotedblleft/quotedblright (medium)

Width ratios (expected relationships):

• endash wider than hyphen (traditionally 2x)

• emdash wider than endash (traditionally 2x)

• quoteright similar width to comma

• exclam narrower than question

Skips any pairs where glyphs are missing. If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks mismatches red, width warnings yellow, and passing glyphs green.

Args: master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Cross-validate related figures and letters (0↔O, 6↔9, 8↔S, 3↔B, etc.).

Based on industry patterns across professional fonts. Checks width ratios between pairs that should be structurally related:

• six ≈ nine: rotated forms, should match (high severity)

• zero < O: zero narrower and lighter (medium)

• three ≈ five: related open-bowl figures (medium)

• three < B: three narrower than B (medium)

• eight ~ S: related S-shape (low/informational)

• one > I: one wider due to flag/crossbar (low/informational)

If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks severe failures red, warnings yellow, and passing glyphs green.

Args: master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Compare typographic color (ink density) across multiple glyphs.

RECIPE: For a full consistency audit, follow get_recipe("audit_consistency").

Finds glyphs that are visually too dark or too light compared to the group. Uses per-glyph expected density ratios from industry patterns — each glyph gets a verdict: pass, compensation, inconsistent, or unreliable.

Reference glyphs: n (lowercase), H (uppercase).

If master_id is omitted, analyzes ALL masters and returns per-master results. Glyph color in GlyphsApp = worst verdict across all masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks:

• Red (0) = inconsistent density

• Orange (1) = unreliable measurement

• Yellow (3) = optical compensation (expected)

• Green (4) = pass

Args: glyph_names: Glyphs to compare master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Examples: "Is the color consistent across uppercase?" -> compare_color(["H","I","M","N","O","B","D","E","F","K","L","P","R"])

Compare width proportions across glyphs within a font.

RECIPE: For a full consistency audit, follow get_recipe("audit_consistency").

Checks three things:

1. Related-form groups: b≈d≈p≈q (mirrored), h≈n≈u (arch), O≈Q, etc.

2. Width ordering: m>n>r, W>H>I — flags violations

3. Industry ranges from 18 professional fonts — flags outliers

References: n for lowercase, H for uppercase/figures.

If no glyph_names provided, checks all LC + UC + figures. If master_id is omitted, analyzes ALL masters.

Does not modify glyph colors by default. When mark_glyphs=True, marks inconsistencies red, range warnings yellow, and passing glyphs green.

Args: glyph_names: Optional list of glyphs to check master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Compare stem thicknesses across multiple glyphs to find inconsistencies.

RECIPE: For a full font audit (stems + color + proportions + spacing), call get_recipe("audit_consistency") — it runs checks in dependency order.

Evaluates each glyph against industry stem patterns for optical compensation. Per-glyph verdicts:

• pass: stem within expected tolerance (green in GlyphsApp)

• compensation: known optical compensation like round stems, bowl mass (yellow) — only flagged if OUTSIDE the expected range

• inconsistent: real issue, deviation exceeds industry norms (red)

• unreliable: glyph shape can't be reliably measured (orange)

Each glyph is classified into one of 5 groups:

• straight: pure stems (n,h,m,u,i,j,l,r / H,I,L,T,U,F,E,K,J)

• round: pure round forms (o,c / O,C,Q)

• mixed: stem + bowl (b,d,p,q,g,a,e,s / D,B,P,R,G)

• diagonal: diagonal strokes (v,w,x,y,z,k / V,W,X,Y,Z,A,M,N)

• optical/figure: special cases (t,f) and numbers (0-9)

Supports uppercase (ref: H), lowercase (ref: n), and figures (ref: H).

If master_id is omitted, analyzes ALL masters and returns per-master results. Glyph color = worst verdict across all masters. If master_id is provided, analyzes that single master only.

Does not modify glyph colors by default. When mark_glyphs=True, marks: Red=inconsistent, Orange=unreliable, Yellow=compensation, Green=pass

Args: glyph_names: List of glyphs to compare master_id: Optional master ID (empty = all masters) mark_glyphs: Color glyphs by verdict only when explicitly requested

Create a new glyph in the open font.

Args: glyph_name: Name for the new glyph (e.g., "a.ss01", "uni0041") width: Advance width in font units unicode_value: Optional unicode value (e.g., "0061" for 'a') paths: Optional initial paths (same format as set_glyph_paths)

Create a new workflow recipe.

Recipes are markdown files with numbered steps. Follow this format:

Recipe: My Recipe Title

Description of what this recipe does.

Steps

1. First step title

• tool_name — what it does

• another_tool — with parameters

2. Second step title

• tool_name — instructions

Args: name: Snake_case identifier (e.g. 'fix_spacing_issues') content: Full markdown content of the recipe overwrite: If true, replace existing recipe with same name

Delete a glyph from the font. This cannot be undone via MCP.

Delete a kerning pair.

Args: left: Left glyph name or group (@MMK_L_...) right: Right glyph name or group (@MMK_R_...) master_id: Optional master ID (uses first master if empty)

Delete a workflow recipe.

Args: name: Recipe name to delete (e.g. 'old_workflow')

Duplicate a glyph (all layers and paths) under a new name.

Useful for creating alternates or backups before editing.

Execute arbitrary Python code inside GlyphsApp.

The code runs with access to the Glyphs object and all GlyphsApp API. stdout is captured and returned. This is powerful but must be used carefully.

NOTE: This endpoint is disabled by default. The user must enable it in GlyphsApp preferences (com.nico.glyphs-mcp.allowExecute = True).

RECIPE: Do not improvise multi-step work here. To create a Glyphs plugin or script, follow get_recipe("create_glyphs_plugin") or get_recipe("create_glyphs_script"). For bulk layer cleanup, follow get_recipe("cleanup_dated_layers").

Example: execute_in_glyphs("print(Glyphs.font.familyName)")

Export the open font beside its saved source with glyphs-cli.

Creates export/YYYY-MM-DD_HH-MM-SS next to the open .glyphs or .glyphspackage source. Static instances are exported as OTF, TTF, WOFF, and WOFF2. Variable instances are exported as variable TTF files. Previous export directories are never removed or overwritten.

The response always contains portable exportLog and colored exportLogAnsi variants. The calling agent MUST show the ANSI variant when its client supports terminal colors, otherwise the portable log, after every export attempt including failures.

Args: save_before_export: Save pending changes before exporting. Defaults to False; if the document is edited, the tool asks for confirmation instead of silently saving it. timeout: Maximum seconds for each of the three export runs.

Generate Unicode box drawing and block element glyphs in the open font.

By default, processes U+2500–U+259F. Existing drawn glyphs are skipped unless overwrite=True. The tool draws directly in the .glyphs source across all masters, using auto-detected stem values when stroke params are left at 0.

Args: glyph_names: Optional subset to generate. Accepts glyph names, single characters, or codepoints like "U+2500". overwrite: Replace existing drawings if True. width: Force advance width for generated glyphs. 0 = auto. stroke: Light/single stroke thickness. 0 = auto. heavy_stroke: Heavy stroke thickness. 0 = auto. double_gap: Gap between double-line strokes. 0 = auto. color: Optional glyph color label for newly created glyphs.

Get OpenType feature code from the font.

Get information about the currently open font in GlyphsApp.

Returns font family name, units per em, glyph count, masters, axes, metrics (ascender, descender, x-height, cap height), and instances.

Get complete data for a specific glyph including all paths and metrics.

Returns all layers with: paths (nodes with x,y coordinates, type, smooth), components, anchors, width, sidebearings.

Node types: "line" (straight on-curve), "curve" (smooth on-curve), "offcurve" (cubic bezier control point). Path direction: -1 = counter-clockwise (outer contours), 1 = clockwise (inner contours/counters).

Get a glyph rendered as SVG markup.

Returns SVG with viewBox matching the glyph's metrics. Useful for seeing the glyph shape as a vector image.

Get kerning pairs for a specific master (or first master if not specified).

Args: master_id: Master ID. Empty = first master. left: Filter by left glyph/group name. Empty = all. limit: Max pairs to return. 0 = all. Use limit=50 for large fonts.

Get all font masters with their metrics and axis positions.

Returns master ID, name, ascender, descender, x-height, cap-height, and axis values for each master.

Get a specific workflow recipe by name.

Returns the full recipe with step-by-step instructions, plus totalSteps count. Use get_recipe_step() to read and execute one step at a time.

Args: name: Recipe name (from list_recipes, e.g. 'scale_proportions')

Get a single step from a recipe for sequential execution.

Returns step title, content, and a MANDATORY directive field. You MUST follow the directive — it tells you exactly what to do next.

The response includes:

• step: current step number

• totalSteps: total steps in recipe

• title: step title

• content: tools to call and instructions

• directive: MANDATORY instruction for what to do after this step

IMPORTANT: Execute ALL tools listed in the step content before proceeding. Do NOT skip steps. Do NOT combine steps. Follow the directive field.

Args: name: Recipe name (e.g. 'audit_consistency') step: Step number (1-based)

Get the user's current selection in GlyphsApp's editor.

Returns the active glyph name, layer, and any selected paths or nodes. Returns null selection if no tab or layer is active.

Get spacing test strings for visually evaluating a glyph's spacing.

RECIPE: For systematic spacing work, follow get_recipe("spacing_workflow").

Generates canonical test strings based on industry-standard methods:

• Three-at-a-time (OH no Type Co): glyph sandwiched between n/o or H/O

• Systematic pairs (Jamra): glyph paired with every letter in its case

• Cross-case integration: glyph in mixed UC/LC context

• Ruder test: hard vs easy word columns for overall color evaluation

• Single-stem stress test: words like "millennial", "minimum" (for i, l, r, t)

Use these strings in GlyphsApp's Edit view to visually assess spacing quality.

Args: glyph_name: Name of the glyph to generate test strings for

Get the designer's intended stem values from the Dimensions palette.

Returns stem snap values from custom parameters AND measured values from reference glyphs (H, O, n, o). These are the TARGET values that other glyphs should match.

Use this as baseline for compare_stems — to check if glyphs hit the designer's intended values, not just if they're consistent with each other.

List glyphs in the open font with basic metadata.

Returns glyph names, unicodes, category, subCategory. Does NOT include path data — use get_glyph() for full details.

Args: category: Filter by category — "Letter", "Number", "Punctuation", "Symbol", "Separator", "Mark", "Other". Empty = all. limit: Max glyphs to return. 0 = all.

List available workflow recipes.

Recipes are step-by-step guides for complex type design tasks. They tell you which tools to call, in what order, and what to check.

IMPORTANT: You MUST call this before starting any multi-step type design task (scaling, auditing, spacing, kerning, compatibility checks, etc.). If a recipe matches the task, call get_recipe(name) and follow its steps in order — they encode expert type design knowledge and dependency ordering.

Measure the ink density (typographic color) of a single glyph.

Ink density = ratio of filled area to total bounding box. Normalizes by the appropriate zone height (x-height for lowercase, cap-height for uppercase) so values are comparable across glyphs.

Returns a value between 0.0 and 1.0 (typically 0.15-0.50 for text fonts).

Higher = darker/heavier glyph. Lower = lighter.

Measure stem thicknesses in a glyph using ray-casting.

Casts horizontal and vertical rays through the glyph outlines to measure vertical stems (like the main strokes of n, m, h) and horizontal stems (like crossbars of e, A, H).

Returns: - Dominant (most common) vertical and horizontal stem values - Min/max range showing consistency within the glyph - Detailed per-ray measurements with positions

Use this BEFORE and AFTER applying RMX filters to verify the effect.

Examples: "How thick are the stems of R?" -> measure_stems("R") "What's the crossbar thickness of H?" -> measure_stems("H")

Rename a glyph. Fails if new_name already exists.

Run a comprehensive production readiness review on the open font.

Checks 44 items across critical/warning/info severities:

Critical (must fix): family name, .notdef, space glyph, duplicate unicodes/names, master compatibility, vertical metrics, open paths, valid glyph names, missing components, alignment zones.

Warning (should fix): metadata, version, essential glyphs, .notdef outlines, zone overshoots, Use Typo Metrics, typo/hhea match, win metrics coverage, kerning groups, cross-master kerning, critical kern pairs, OT features, weight classes, style linking, nbspace width, zero-width letters, PANOSE, stems defined, short segments, near-miss alignments, presentation forms decomposition (fi/fl/ff), German sharp S, Dutch IJ localization, smallcap completeness, salt feature, languagesystems prefix, Remove Overlap.

Info: glyph count by category, font metrics, fsType, VF readiness, unreachable glyphs.

Returns a formatted markdown report with pass/fail status and details for failures.

Apply an RMX filter to multiple glyphs at once.

RECIPE: For multi-glyph scaling, call get_recipe("scale_proportions") first.

Args: filter_name: One of "harmonize", "tune", "scale", "monospace" glyph_names: List of glyph names to process params: Filter-specific parameters (same as individual tool params) master_id: Optional master ID

Examples: "Harmonize all lowercase" → rmx_batch("harmonize", ["a","b",...,"z"], params={"mode": "harmonize"})

"Make all caps 20% wider" →
rmx_batch("scale", ["A","B",...,"Z"], params={"width": 120})

Optimize bezier curves on a glyph using RMX Harmonizer.

Modes:

• "harmonize": Full curve optimization (recommended default)

• "dekink": Only fix kinks at smooth connections

• "extract handles": Reset handles to default positions

• "supersmooth diagonals": Extra smoothing on diagonal segments

• "supersmooth all": Maximum smoothing everywhere

Use after drawing or modifying paths to ensure clean curves. Works on any glyph — no multi-master requirement.

Adjust a glyph to a fixed width using RMX Monospacer.

Intelligently distributes width change between outline scaling and spacing adjustment to maintain visual quality.

Args: glyph_name: Name of the glyph mono_width: Target advance width (0 = keep current width) keep_stroke: How much to preserve stroke weight, 0-100% use_spacing: How much width change goes to spacing vs outline, 0-100% master_id: Optional master ID

Example: "Make all uppercase letters 600 units wide" → rmx_batch("monospace", ["A","B",...,"Z"], params={"monoWidth": 600})

Requires 2+ masters.

Scale a glyph by percentage in width and/or height.

USE THIS for percentage-based scaling requests like "make 30% wider".

RECIPE: For a multi-glyph scaling task, call get_recipe("scale_proportions") first and follow it step by step.

Uses RMX Scaler with stroke-weight compensation via master interpolation. Native affine fallback is opt-in because it cannot preserve stem weight. Response includes a "method" field: "rmx" = RMX Scaler was used, "native_transform" = affine transform fallback.

Args: glyph_name: Name of the glyph to scale width: Width scale as percentage. 100 = no change, 130 = 30% wider, 70 = 30% narrower height: Height scale as percentage. 100 = no change weight: Stroke weight delta (RMX only, ignored in native fallback) adjust_space: Sidebearing adjustment delta vertical_shift: Vertical position offset master_id: Optional active master ID. RMX still processes all masters. allow_fallback: Permit native affine scaling if RMX fails. Default False.

RMX parameters accept either one value for every master or a list in
font master order for independent per-master control.

Examples: "Make R 30% wider" → rmx_scale("R", width=130) "Make R 20% narrower" → rmx_scale("R", width=80) "Scale R to 90% height, keep width" → rmx_scale("R", height=90)

Adjust a glyph by delegating directly to the installed RMX Tuner.

This tool calls the real RMXTuner instance loaded in GlyphsApp (Glyphs.filters) and passes the values to Tuner's own controls. It does NOT approximate Tuner with native interpolation.

IMPORTANT: Width/height/weight/slant are RMX Tuner deltas, not percentages. Typical useful range is roughly -100 to +100, depending on the font/RMX setup. Blend is normalized: 0 = no blend-in layer, 1 = full blend-in layer. Values above 1 extrapolate and can produce extreme outlines.

Args: glyph_name: Name of the glyph to tune. weight: RMX Tuner Weight value (+ = heavier, - = lighter). width: RMX Tuner Width value (+ = wider, - = narrower). height: RMX Tuner Height value (+ = taller, - = shorter). slant: RMX Tuner Slant value. blend: RMX Tuner Blend value. Use 0.0–1.0 for interpolation. fixed_width: Keep advance width fixed via RMX Tuner's checkbox. master_id: Optional master/layer ID. Empty = first master. all_masters: If True, pass all master layers of the glyph to RMX Tuner.

Example: rmx_tune("R.001", height=88, weight=88)

Create or update an OpenType feature.

Args: feature_name: Feature tag e.g. "liga", "kern", "ss01" code: OpenType feature code (AFDKO syntax) active: Whether the feature is enabled (default True)

Set the color label of a glyph in the font view.

Color index (0–11): 0=red, 1=orange, 2=brown, 3=yellow, 4=light green, 5=dark green, 6=teal, 7=blue, 8=purple, 9=pink, 10=light gray, 11=charcoal

Use None/no color by setting any value outside this range.

Replace ALL paths on a glyph's layer in GlyphsApp.

This OVERWRITES existing paths. The glyph must already exist.

Each path is: {"closed": true, "nodes": [{"x": 100, "y": 0, "type": "line", "smooth": false}, ...]}

Node types:

• "line": on-curve point with straight connection to previous

• "curve": on-curve point with smooth cubic bezier connection

• "offcurve": cubic bezier control handle (always in pairs before a "curve")

• Curve segments: offcurve, offcurve, curve (3 nodes per segment)

Path direction: outer contours counter-clockwise, counters/holes clockwise. correctPathDirection() is called automatically after setting paths.

If master_id is empty, uses the first master.

Set the unicode value of a glyph.

Args: glyph_name: Name of the glyph to update unicode_value: Hex unicode string e.g. "0061" for 'a'. Pass "" to clear.

Set the advance width of a glyph.

Set a kerning pair value between two glyphs.

Args: left: Left glyph name or group (@MMK_L_...) right: Right glyph name or group (@MMK_R_...) value: Kerning value (negative = tighter) master_id: Optional master ID (uses first master if empty)

Scale glyphs with automatic stem weight compensation.

RECIPE: For multi-glyph scaling tasks, call get_recipe("scale_proportions") first — it includes pre/post stem verification and visual comparison steps.

Unlike simple affine transforms which distort stem weights, this tool:

1. Measures reference stems (H for UC, n for LC) before scaling

2. Applies the width/height transform

3. Uses GlyphsFilterOffsetCurve to compensate stem thickness changes

4. Reports before/after stem measurements for verification

All values are scale factors where 1.0 = no change.

Args: width: Horizontal scale factor. 0.97 = 3% narrower, 1.1 = 10% wider height: Vertical scale factor. 1.15 = 15% taller, 0.9 = 10% shorter weight: Target stem weight factor. 1.0 = maintain original stem thickness after scaling (compensate). 0.9 = make stems 10% thinner. 1.1 = 10% thicker. proportional: If true, height follows width (uniform scale with compensation) glyph_names: List of glyph names to process (empty = all exporting glyphs) master_id: Process only this master (empty = all masters) backup: Create backup layers before modifying (default true)

Examples: Condense 3% keeping weight: smart_scale(width=0.97, weight=1.0) Increase x-height 15% keeping weight: smart_scale(height=1.15, weight=1.0) Scale uniformly 90% with weight compensation: smart_scale(width=0.9, proportional=True) Make all stems 10% thicker: smart_scale(weight=1.1) Condense UC only: smart_scale(width=0.95, glyph_names=["A","B","C",...])