Native BX Fonts vs Regular BX Fonts in Embrilliance: The Resizing Trap That Wrecks Lettering (and How Pros Avoid It)

If you’ve ever resized embroidery lettering in software, hit “stitch,” and then watched the real stitch-out look… oddly cheap (gaps, jagged outlines, jump trims everywhere), you’re not alone. I call this the "Screen vs. Reality Gap," and it’s the number one confidence killer for newcomers.

I’ve seen this exact problem cost shops real money: extra stabilizer, extra thread, waste of expensive blanks, and the worst one—redoing a garment you can’t “un-stitch.” The good news is that in Embrilliance, a lot of that pain comes down to one simple fork in the road:

Are you resizing a Native BX font (object-based), or a regular BX font (stitch-based)?

Once you can tell the difference—and you know when to use Nearest Point—your lettering workflow gets calmer, faster, and far more predictable.

Don’t Panic: “My Font Resized Fine on Screen” Is the Most Expensive Lie in Machine Embroidery

On-screen previews are helpful, but they can be forgiving. Real fabric is not. When a digitized file claims it looks "fine" on a monitor, it isn't accounting for the push and pull compensation of physical thread.

In the video, Lindsay (Lynnie Pinnie Embroidery) shows a clean, professional truth: Native BX fonts recalculate stitches when resized, while regular BX fonts mostly stretch what’s already there. That difference is why one stitch-out looks crisp and the other shows long stitches, messy bean outlines, and even needle holes on knit.

The Sensory Check: When a machine runs a poorly scaled stitch file, it sounds different. Instead of a rhythmic, smooth hum, you will often hear a laboring thump-thump as the needle tries to penetrate dense areas, or a "slap" sound if the stitches are too long and loose.

If you’re running a home setup, this is frustration. If you’re running a small shop, this is profit leakage.

One quick mindset shift that saves a lot of rework: treat lettering like a “system” (font type + stitch logic + fabric + stabilizer), not just a file you can scale freely.

Spot Native BX Fonts in Embrilliance Font Lists (The Needle Icon Test You’ll Use Forever)

Lindsay gives the cleanest identification method I’ve seen for Embrilliance users. Think of this as your traffic light system before you even start designing.

The Needle Icon Protocol:

• Regular BX fonts (STOP/CAUTION): Show a small needle icon next to the font name. These are static stitch files mapped to keys.
• Native BX fonts (GO): Do not show the needle icon. These are scalable objects.
• Display Logic: In the font list, regular BX fonts often appear as multiple entries for different sizes (e.g., Font_1inch, Font_2inch), because they are individual files. Native BX fonts appear as one scalable entry, because the software calculates the math on the fly.

That’s it. No guessing.

This matters because regular BX fonts are “pre-built stitches.” When you resize them, Embrilliance can only do its best to stretch/shrink stitches, similar to zooming in on a pixelated .JPG image.

Native BX fonts, on the other hand, behave more like “vector graphics” inside the Embrilliance ecosystem—so the software can rebuild stitch properties (density and underlay) as you scale.

The “Hidden” Prep Pros Do Before Resizing Lettering in Embrilliance (So the Stitch-Out Matches the Screen)

Before you touch a resize handle, do the boring checks that prevent the dramatic failures later. A lot of lettering disasters aren’t just “bad resizing”—they’re bad resizing + weak stabilization + the wrong expectations for the fabric.

If you’re stitching on knits (as shown in the stitch-out comparison), you’re already in a high-risk zone. Knits move. If your file is distorted and your fabric stretches, you will get gaps.

Here’s the prep I’d do in a real production workflow—especially if the design is going on a customer garment.

Prep Checklist (The "Pre-Flight" Routine):

• File Diagnosis: Confirm if the font is Native BX (safe to scale) or regular BX (limit scaling to +/- 10-20%).
• Stitch Review: Identify high-risk features (bean stitch outlines, sketchy fills, or gradients).
• Fabric Stability: Is it "forgiving" (stable woven cotton) or "honest" (stretchy knit)?
• Consumables Check:
  • Needle: Clean 75/11 Ballpoint for knits; 75/11 Sharp for wovens. Replace if used for >8 hours.
  • Stabilizer: Use Cutaway (Polymesh) for knits. Tearaway is rarely sufficient for dense lettering on T-shirts.
  • Helpers: Have temporary spray adhesive (like 505) and water-soluble topping (Solvy) ready to prevent sinking stitches.

One practical shop note: if you’re doing repeated garment runs, your hooping consistency matters as much as your software choices. When hooping is slow or inconsistent, operators tend to “force” fixes in software (like resizing stitch files) instead of fixing the real bottleneck.

If hooping is your bottleneck, a dedicated setup like a hooping station for machine embroidery can be the difference between saying “I’ll just stretch this design a bit” versus “I’ll hoop correctly and stitch it right the first time.”

Resize a Native BX “Sketchy” Font Without Losing the 5-Pass Bean Stitch (What You Should See)

In the video, Lindsay types lettering and demonstrates resizing a Native BX version of the “Sketchy” font.

Key detail: this font uses a bean stitch outline that runs five times (back-and-forth passes) plus a sketchy fill. When she scales the Native BX lettering up significantly by dragging the corner handles, the software recalculates:

• Density Maintenance: Such as staying around the standard 0.4mm spacing regardless of size.
• Outline Integrity: The bean stitch remains a tight, triple-pass look rather than stretching into a loose running stitch.
• Visual Balance: The lettering doesn’t get that “stretched apart” look.

Checkpoint: As you scale, look at the 3D preview. The stitches should still look like they belong to the same font—just bigger.

Expected outcome: Clean outline rhythm, consistent fill character, no weird gaps. This is the core promise of Native BX: you’re not just resizing geometry—you’re letting Embrilliance rebuild stitch logic.

Resize a Regular (Needle-Icon) BX Font and Watch Density Fall Apart (The Distortion You Can’t Unsee)

Then Lindsay does the same resize move on the regular BX version. What happens is exactly what experienced digitizers fear regarding stitch-based scaling:

• Density Drift: Stitch spacing expands directly with the size. If you double the size, you double the gap between stitches.
• Stitch Elongation: Stitch length becomes dangerously long, prone to snagging.
• Outline Failure: The bean stitch outline becomes messy, looking like erratic dashed lines.

Her wording is important: the software is “doing its best,” but it cannot truly recalculate density for stitch-based files.

Checkpoint: If your bean stitch starts looking like uneven dashed lines instead of a confident, solid outline, you have hit the wall of stitch-based scaling.

Expected outcome: Usable for very minor adjustments (5-10%), but visibly unprofessional if scaled 20% or more.

Warning: Mechanical Safety
If you resize stitch-based lettering down (shrinking it), the density increases. This can create a "bulletproof" patch where the needle strikes the same spot repeatedly. This causes heat buildup, thread breaks, and even needle breakage, which can send metal shards flying. Always wear eye protection and avoid shrinking dense files.

Kill Jump Stitches in Script Fonts: The Embrilliance “Nearest Point” Toggle That Saves Minutes per Name

If you do names, monograms, team gear, or anything script-heavy, jump stitches are where time goes to die.

Lindsay demonstrates this using a chain stitch script font (“Sheeba”) and the Nearest Point feature. This is a game-changer for throughput.

Here’s the workflow inside Embrilliance:

1. Select the script lettering object.
2. Navigate to the Stitch tab in the properties panel.
3. Click the Nearest Point toggle.

When Nearest Point is ON, Embrilliance dynamically re-routes the start/stop points of each letter so they flow into each other—eliminating the need for the machine to trim and jump between letters.

Checkpoint: Watch the connection points in the software. You’ll see the green/red start/stop points move, and the distinct "jump line" (usually a dotted line) disappear.

Expected outcome: A fluid script look, 50% fewer trims, faster machine run time, and no "bird's nests" underneath the fabric from constant trimming.

When Nearest Point Is Off: The Jump Lines That Turn Pretty Script into a Trim-Fest

Lindsay shows the contrast clearly: with Nearest Point disabled, you can see jump lines between letters.

In real stitching, that means:

• More Trims: Every trim adds about 7-10 seconds to the job and risks the thread pulling out of the needle eye.
• Thread Nests: More starts/stops mean more chances for bobbin tangles.
• Manual Labor: You (or your customer) will have to trim those tails by hand.

If you’re selling finished goods, those tiny thread tails are the kind of detail customers may not have the vocabulary to describe—but they absolutely notice as "low quality."

This is also where workflow matters. If you’re hooping slowly and already behind schedule, you’re more likely to accept jumpy lettering “as-is” just to get it done. Clean up the workflow first.

For shops doing repeated personalization, pairing clean script connections with consistent hooping is a real throughput upgrade. If you’re currently fighting with standard machine embroidery hoops that leave marks or take too long to load, upgrading to magnetic frames can be a practical next step to reclaim that lost time.

The Gradient Fill Reality Check: Why “JACOBY” Resizes Beautifully in Native BX (and Breaks in Stitch-Based Files)

Next, Lindsay switches to a complex two-color gradient fill font (“Jacoby/JACOBY”) with an outline. This is an advanced stress test.

She demonstrates two versions:

• Native BX gradient font: Resizing preserves the mathematical ratio of the fade/transition. The gradient remains smooth.
• Stitch-based version: Resizing creates "banding" (stripes of color), broken fill areas, and feathered outlines that look fuzzy rather than sharp.

Her analogy is dead-on: Native BX is like speaking the same language as Embrilliance (created in StitchArtist), while resizing a stitch-based file is like “Google Translate”—you get the gist, but the nuance is destroyed.

The "Why" - Physics of Thread: Gradient fills rely on precise overlapping of different thread colors. When you stretch a stitch file, you pull those overlaps apart, revealing the fabric underneath.

The Safe Resizing Window: Why This Native Gradient Font Is Limited to 1"–3" Tall

Lindsay also shares a practical constraint that even many pros skip: Just because it's Native doesn't mean it's magic.

• The gradient font is specially engineered to resize down to about 1 inch and up to about 3 inches.
• She notes it won’t let you scale endlessly because it’s a lot of fill stitch at the same angle.
• The Physics: Detailed gradients become mud if shrunk too small (thread piling), and become loose/gappy if made too large (long satin stitches).

That’s a professional move: Native doesn't mean infinite. It means “recalculates correctly within the design’s intended engineering limits.”

A practical decision point: if you’re resizing toward the upper limit on a knit, don’t just “hope.” Stabilize like you mean it. Use a heavy Cutaway (2.5oz or 3.0oz) or float a second layer restricted to the design area.

Side-by-Side on Screen: Object-Based vs Stitch-Based Gradient Resizing (What to Look For Before You Stitch)

Lindsay shows the two versions side-by-side. You must train your eyes to see these defects on screen so you don't waste garments.

Visual Inspection Checklist:

1. Orphan Stitches: Look for random straight stitches that don’t match the design direction.
2. Broken Gradients: Do fills look like solid blocks or separated islands?
3. Fuzzy Edges: Are the Running Stitch outlines sitting on the fill edge, or drifting off?

If you see these on screen, they rarely improve on fabric. They usually get worse due to fabric shifting.

This is also where a lot of people waste consummables: they keep testing, changing thread brands, changing needles—when the real issue is that the file is stitch-based and being pushed beyond its geometry.

The “Stray Stitches” Close-Up: How Stitch-Based Resizing Creates Messy Fills and Jagged Outlines

The close-up Lindsay shows is the kind of thing that makes operators say, “My machine is acting up.”

But often, the machine is mechanically perfect. The file is simply asking the needle to do something unreasonable:

• Long Stitches: Sags that catch on buttons or zippers.
• Broken Logic: Fills that leave millimeter-wide gaps where fabric shows through.
• Lack of Underlay: Native files calculate new underlay (foundation stitches) for the new size. Stitch files just stretch the old underlay, leaving the top stitches unsupported.

Expert Tip: If your machine starts sounding harsher on dense areas, slow down immediately (drop speed from 800 SPM to 600 SPM). Machines often tell you audibly when a design is poorly digitized or improperly scaled.

The Stitch-Out Proof on Knit Fabric: Clean Native Lettering vs Needle Holes from Resized Stitch Files

Finally, Lindsay stitches out the original “Sketchy” example on knit fabric. The physical result confirms the theory.

• Top sample (Native): Clean sketchy fill. The bean stitch sits on top of the knit ribs.
• Bottom sample (Limit-pushed Stitch file): Long, sloppy stitches. More critically, visible needle holes.

Why the holes? Because the stitch file couldn't adjust the density, it likely hammered the same points of the knit fabric repeatedly or pulled the fibers too hard due to lack of compensation.

The "Billion Dollar" Lesson: If you sell garments, needle holes are a brand killer. Customers see them as "damage."

Warning: Magnetic Hoop Safety
If you decide to upgrade to magnetic hoops to better handle knits (preventing hoop burn), treat them with respect. Strong magnets can pinch fingers severely, causing blood blisters. Always slide magnets off rather than pulling them apart, and keep them away from pacemakers or sensitive electronics.

The “Why” Behind It: Object-Based Recalculation vs Stitch Stretching (So You Stop Fighting Your Software)

Here’s the simplest way to internalize what Lindsay demonstrates.

• Native BX (Object-Based): Think of this like a vector line in Adobe Illustrator. It has math that says "Draw a line from A to B with X density." When you move B, the math fills in the new space perfectly.
• Regular BX (Stitch-Based): Think of this like a JPG photo. It is a grid of fixed points. When you stretch it, you just get pixelation (or in embroidery terms, gaps and loose threads).

That’s why sketchy fills and bean stitches are “notorious for not resizing well” when they’re stitch-based: their look depends on carefully controlled spacing and repetition.

And it’s why Nearest Point is such a big deal for script: it’s not just visual—it’s pathing efficiency.

The Golden Rule: If the file is stitch-based, respect the digitized size (scale no more than +/- 10%). If it’s Native, resize within the limits the designer intended, but trust the software to handle the math.

Stabilizer Decision Tree for Lettering on Cotton vs Knit (Because Resizing Isn’t the Only Variable)

The video shows knit fabric in the stitch-out comparison, and Lindsay explicitly notes stabilization matters. Even a Native file will pucker if the stabilization is wrong.

Here is a quick industry-standard decision tree for your next project:

Decision Tree: Fabric → Stabilizer Choice

1. Is the fabric knit (T-shirt/Polo/Hoodie) or stretchy?
   • Yes: MUST USE CUTAWAY (Polymesh). No exceptions for beginners. Tearaway will eventually fail and distort the lettering during the wash.
   • No (Stable/Woven/Denim): You can use Tearaway, but dense lettering often looks crisper with Cutaway.
2. Is the lettering dense/complex (bean stitch, gradient)?
   • Yes: Use a heavier Cutaway (2.5oz) or two layers of Polymesh. Consider slowing the machine to 600 SPM.
   • No (Simple Satin): Standard stabilization is usually fine.
3. Are you seeing needle holes or fabric distortion?
   • Immediate Action: Stop resizing stitch-based files. Switch to Native. Ensure your hooping is "drum-tight" but not stretched.

This is also where hooping quality becomes “invisible insurance.” If the fabric is shifting in the hoop, even a perfect Native font can stitch poorly.

If you routinely struggle with hoop burn (shiny rings on fabric), slow loading times, or inconsistent tension, upgrading to magnetic embroidery hoops is often the cleanest way to stabilize the process—not just the fabric.

Setup Habits That Keep Native Fonts Looking Native (Not Like a Rescue Mission)

Native BX gives you flexibility, but your setup still decides whether the stitch-out looks premium.

Here are the habits I’d standardize in any studio doing names/logos regularly:

Setup Checklist (Before you hit "Start"):

• Verify Font: Is it Native (no needle icon)? If not, is the size change <10%?
• Optimize Path: Is "Nearest Point" ON for script text?
• Boundary Check: Is the final height within the font's 1"-3" (or designer specified) range?
• Surface Prep: Did you use a water-soluble topping (Solvy) for knits to keep stitches elevated?
• Hooping Check: Is the fabric neutral (not stretched)? Are you relying on software scaling to fix a bad hoop job?

If you’re doing personalization at volume, the fastest shops don’t just “get good at hooping”—they systemize it. A consistent hooping workflow comes from using the right fixtures, reducing the temptation to distort designs in software just to make them fit.

Comment-Driven Pro Tips: Updating Old Fonts, and the Real “Game Changer” Question

One viewer effectively called this Native BX feature a “game changer” and asked about updating old archives.

Here’s the practical, experience-based answer—without overpromising:

• Retrofitting: If your old fonts are stitch-based, you generally cannot magically turn them into true Native objects without re-digitizing or buying the Native version from the designer.
• The Workflow Fix: Build a "Safe Workflow." Keep stitch-based fonts near their digitized size (e.g., use them for monograms that are always 4 inches). Reserve your resizing freedom for modern Native BX fonts.

That’s the real game changer: knowing which tool you’re holding before you use it.

If you’re running a small business, this connects directly to throughput. Every extra test stitch-out is time you can’t bill. When you scale beyond a hobby pace, ask yourself: Is my bottleneck software time, hooping time, or machine time?

For many studios, hooping is the first bottleneck. If you use a DIY setup, adding a purpose-built hooping station for embroidery can make your placement repeatable. Repeatability is what makes lettering orders profitable.

The Upgrade Path: From “It Works” to “It’s Repeatable” (Software + Hooping + Production Choices)

Lindsay’s video is software-focused, but the stitch-out comparison proves a bigger point: quality is a chain.

Here’s a clean upgrade path I recommend when you want fewer failures and more consistent output:

1. Software Discipline (Zero Cost):
   • Use Native BX for scalable designs.
   • Always use Nearest Point for script.
   • Respect the physical limits of the thread (don't scale tiny fonts up infinitely).
2. Consumables Discipline (Low Cost):
   • Match stabilizer to fabric stretch (Knits = Cutaway).
   • Change needles every 8-10 hours of machine runtime.
   • Keep "hidden" consumables (Spray adhesive/Solvy) stocked.
3. Workflow Discipline (Time Saver):
   • Standardize hooping tension.
   • If hooping creates "hoop burn" or takes >2 minutes per shirt, treat hooping for embroidery machine limitations as a process problem, not a skill issue.
4. Hardware Upgrades (Production Scale):
   • Level 2: Magnetic Hoops. These reduce hooping time by 50% and eliminate hoop burn on delicate items.
   • Level 3: Multi-Needle Platform (SEWTECH/Brother/etc.). If you are changing threads manually for every color, or trimming jump stitches by hand, a multi-needle machine is where the math starts to make sense for profit.

Operation Checklist (Post-Stitch Quality Control):

• Outline Rhythm: Is the bean stitch consistent, or are there gaps?
• Fill Coverage: Can you see fabric through the gradient?
• Surface: Are there needle holes? (If yes, check file density and needle type).
• Trims: Are script connections clean?
• Record: Write down the "Recipe" (Font/Size/Stabilizer) on the back of your successful sample.

If you take only one lesson from this workflow: Native BX isn’t just a nicer font format—it’s a safer production decision. Combine safe files with consistent hooping tools, and you will stop fixing embroidery and start producing it.

FAQ

• Q: In Embrilliance, how do embroidery users identify a Native BX font versus a regular (needle-icon) BX font before resizing lettering?
  A: Use the Embrilliance needle-icon test: Native BX fonts show no needle icon, while regular BX fonts show a small needle icon and often appear as multiple size entries.
  • Look for the needle icon beside the font name (icon = stitch-based regular BX).
  • Check the font list behavior (many size-specific entries often indicates stitch-based; one scalable entry indicates Native BX).
  • Limit resizing on regular BX to small adjustments (about +/- 10–20% is the safer window mentioned).
  • Success check: In the 3D preview after resizing, a Native BX font still looks like the same font—just larger/smaller—without outlines turning into “dashed” bean stitches.
  • If it still fails… stop scaling the stitch-based font further and switch to the Native BX version (or a font designed for the target size).
• Q: In Embrilliance, what resizing limits should embroidery users follow for regular (needle-icon) BX fonts to avoid gaps, jagged outlines, and needle holes on knit fabric?
  A: Treat regular (needle-icon) BX fonts as stitch files and keep size changes minimal—large scaling commonly causes density drift, long stitches, and messy bean stitch outlines.
  • Keep resizing modest (the blog’s safe guidance is roughly 5–10% for best results; beyond ~20% often looks unprofessional).
  • Avoid shrinking dense stitch-based lettering too much because density increases and can create a “bulletproof” area.
  • Slow the machine down if the design sounds harsh in dense zones (the blog suggests dropping from 800 SPM to 600 SPM as an immediate protective move).
  • Success check: The machine sound stays smooth and rhythmic (not “thump-thump”), and bean stitch outlines remain solid rather than uneven dashed lines.
  • If it still fails… reselect the lettering as a Native BX font (object-based) or choose a font engineered for the final height range instead of forcing stitch-based scaling.
• Q: In Embrilliance, how do embroidery users reduce jump stitches in script fonts using the “Nearest Point” feature for name personalization?
  A: Turn ON “Nearest Point” for the script lettering object so Embrilliance re-routes start/stop points to connect letters and reduce trims.
  • Select the script lettering object.
  • Open the Stitch tab in the properties panel and toggle Nearest Point ON.
  • Recheck the design pathing before saving the stitch file.
  • Success check: The dotted jump lines disappear and the green/red start-stop points move to create smoother letter connections.
  • If it still fails… confirm the lettering is still an editable object in Embrilliance (not already “baked” as fixed stitches) and reapply Nearest Point.
• Q: What needle and stabilizer setup should embroidery users choose for Embrilliance lettering on knit T-shirts to prevent gaps, puckering, and distortion?
  A: For knits, use Cutaway (Polymesh) stabilizer and a ballpoint needle; knits are high-risk, and weak stabilization makes even good files look bad.
  • Install a clean 75/11 Ballpoint needle for knits (replace needles that have more than ~8 hours of runtime per the blog guidance).
  • Hoop the garment neutral (drum-tight but not stretched) and use Cutaway (Polymesh); consider heavier Cutaway (2.5oz–3.0oz) or an extra layer for dense/complex lettering.
  • Add water-soluble topping (Solvy) to prevent stitches from sinking into knit ribs; use temporary spray adhesive (like 505) as needed to control shifting.
  • Success check: Satin/bean outlines sit on top of the knit texture without tunneling, and the fabric does not ripple around the lettering after the hoop is removed.
  • If it still fails… stop blaming thread/needle first and re-check whether the font was stitch-based and resized beyond safe limits.
• Q: What mechanical safety risk happens when embroidery users shrink dense stitch-based lettering, and what is the safest immediate response during machine embroidery?
  A: Shrinking dense stitch-based files can over-increase density, causing heat buildup, thread breaks, and even needle breakage—stop and reduce risk immediately.
  • Stop the job if the needle starts “hammering” one area or the machine sound turns harsh.
  • Reduce speed (the blog’s practical example is dropping from 800 SPM to 600 SPM) before continuing any dense section.
  • Wear eye protection when testing dense designs, especially after resizing down.
  • Success check: Thread runs without repeated breaks and the machine returns to a smooth, even stitch sound through dense areas.
  • If it still fails… abandon the shrunken stitch-based version and use a Native BX font or a properly digitized size instead of forcing density.
• Q: What safety rules should embroidery users follow when handling magnetic embroidery hoops to reduce hoop burn on delicate knits?
  A: Magnetic hoops can help reduce hoop burn, but strong magnets can pinch fingers severely—slide magnets off and keep magnets away from pacemakers and sensitive electronics.
  • Slide magnetic clamps off instead of pulling them straight apart to avoid sudden snap-pinches.
  • Keep fingers clear of the closing path before magnets seat.
  • Keep magnetic hoops away from pacemakers and sensitive electronics as a strict precaution.
  • Success check: The hoop loads without finger pinches, and the garment shows minimal or no shiny hoop ring after stitching.
  • If it still fails… slow down the loading routine and standardize handling steps; rushed handling is when most pinch injuries happen.
• Q: For Embrilliance lettering production, what is the best upgrade path when embroidery users keep wasting garments due to resizing issues, slow hooping, and too many trims?
  A: Fix the workflow in layers: first use Native BX + Nearest Point correctly, then stabilize/needle correctly, then consider magnetic hoops for repeatable hooping, and only then consider a multi-needle machine for throughput.
  • Level 1 (Technique): Choose Native BX for scalable lettering and use Nearest Point for script to cut trim time.
  • Level 1 (Limits): Keep stitch-based (needle-icon) fonts near the digitized size and respect any stated height ranges (example shown: some gradients are engineered around 1"–3").
  • Level 2 (Tool): Upgrade hooping consistency if hooping takes longer than ~2 minutes per shirt or causes hoop burn; magnetic hoops often reduce loading time and improve repeatability.
  • Level 3 (Capacity): Move to a multi-needle platform when manual color changes and trim-heavy files are the real time sink.
  • Success check: Fewer test stitch-outs, fewer jump-trim stops, and consistent results across multiple garments with the same “recipe” (font/size/stabilizer).
  • If it still fails… isolate the bottleneck by running one controlled test (same font/size/stabilizer) and change only one variable at a time (file type vs hooping vs stabilization).