Hatch 2.0 Redwork Tool, Done the “Pro” Way: Clean Double-Pass Outlines Without Manual Path Plotting

Redwork looks deceptively simple—until you’ve tried to plot a continuous path by hand and realized you’ve just signed up for an hour of “where do I start, where do I end, and how do I get back without ugly jumps?”

If you’re feeling that panic (or you’ve already learned manual Redwork the hard way), take a breath. You are dealing with a classic tension between "artistic flow" and "machine logic." Hatch Embroidery Software 2.0 gives you a Redwork tool that can do the heavy lifting—but only if you feed it the right kind of digitizing.

Redwork in Hatch Embroidery Software 2.0: The Two Rules You Can’t Bend (and Why They Matter)

Traditional Redwork has strict rules, and the video is crystal clear about them. However, as an embroiderer, you need to understand the physics behind these rules, not just the software logic.

1) Redwork is outlines only—no fill stitches. This means the machine has nowhere to hide. In a fill stitch, the thread sinks into the fabric and creates its own stability. In an outline, the thread sits on top. If your tension is off, it shows. If your stabilizer is weak, it puckers.

2) Every line must stitch over itself exactly twice. That “double-pass” is what makes Redwork look intentional and classic instead of like a single sketchy run.

• The Sensory Check: When a single run stitches, it looks thin and often disappears into the fabric grain. When the second pass hits correctly, the line should "pop" visually, creating a bold, rope-like effect (similar to 12wt thread looking chunky, even if you are using standard 40wt).
  

Here’s the practical reason these rules matter in machine embroidery: outlines are unforgiving. Any wobble from fabric movement, poor stabilization, or sloppy pathing shows immediately. That’s why Redwork is often used as a “clean craftsmanship” style—simple, but not easy.

One more note from the tutorial: you can build Redwork using outline stitch types such as single run, triple run, sculpture run, backstitch, and stem stitch.

The “Old Way” vs. Hatch Redwork Tool: Stop Hand-Plotting Like It’s 2009

Sue calls out what most digitizers learn the hard way: the old method is to print the design, manually plan the travel path, and digitize in a way that guarantees the design goes over itself twice.

That manual plotting is good training—but it’s slow, and it’s easy to digitize yourself into a corner. It forces you to think like a plotter printer rather than an artist.

The Hatch 2.0 Redwork tool changes the workflow: you digitize the outline in segments, making sure segments connect, and then Hatch calculates a continuous double-pass path for you. When it works, it’s a genuine time-saver.

A viewer reaction sums up the business reality: the feature can be “worth the upgrade in saving time alone.” That’s not hype—if you digitize for customers or run a small shop, minutes per file add up fast.

• The Business Trigger: If you are spending 30 minutes plotting a path for a $15 design, you are losing money. Tools that automate logic allow you to focus on volume.

The “Hidden” Prep Before You Digitize Open Shape: Set Yourself Up for a Clean Redwork Calculation

Before you click a single node, do the prep that prevents 90% of Redwork tool frustration. Software is garbage-in, garbage-out.

Prep checklist (Do this BEFORE you digitize)

• Check Design Goal: Confirm the image is strictly line-art (no fills planned).
• Select Tool: In Hatch, choose Digitize Open Shape.
• Set Default Outline: Ensure the outline type is set to Single Run (not Satin or Triple) before you start. This keeps the math simple for the software.
• Identify "Traffic Jams": Mentally mark “branchy” areas (tea pot handles, flower knots, intersections) where stitching will overlap.
• Establish Segment Strategy: Plan to digitize in short, controllable segments. Don't try to draw the whole teapot in one giant line.
• Gather Hidden Consumables: Have your water-soluble pen ready for physical marking, and ensure you have a fresh sharp needle (Box of Organ 75/11s usually works best for standard cotton) to prevent snagging during those double-passes.

If you’re the kind of digitizer who also stitches your own samples, here’s the real-world tie-in: Redwork is often stitched on lightweight fabrics (tea towels, quilting cotton, baby items). Those are exactly the fabrics that show puckering if stabilization is weak. In production, I often recommend treating Redwork like a “precision outline job,” not a casual run stitch.

And if you’re running a shop and doing lots of outline-only personalization (names, simple line art, pocket motifs), this is where workflow upgrades start to matter: a faster digitizing method is great, but so is faster hooping. Many studios pair software speed with physical efficiency tools like a hooping station for machine embroidery when volume grows, ensuring that the perfectly digitized straight line is actually straight on the shirt.

Digitize Open Shape in Hatch: The Click Pattern That Keeps Curves Smooth and Nodes Under Control

In the tutorial, Sue selects Digitize Open Shape from the left toolbar.

Then she digitizes the teapot outline in segments using a simple, reliable input method:

• Left click for straight corner points.
• Right click for curved points.
• Press Enter to finish a segment.

This is one of those “simple but expensive” lessons: too many nodes make Redwork look jittery, but too few nodes make curves collapse. The left/right click rhythm helps you stay intentional.

• The "Beginner Sweet Spot": Aim for a node every 15mm-20mm on gentle curves. If you are clicking every 2mm, you are working too hard and the stitch line will look "choppy."

Warning: Digitizing is low-risk, but stitching isn’t—always keep fingers clear of the needle area during test sew-outs, and never reach under the presser foot while the machine is running. A Redwork design moves fast and changes direction suddenly; don't let a sudden pantograph movement catch your hand.

The One Make-or-Break Rule: Lines Must Touch, Intersect, or Cross Over (or Redwork Will Fail)

This is the core instruction repeated in the video: your lines must connect—touch, intersect, or cross over—so Hatch can calculate the route.

Sue demonstrates this visually with an intersection callout on the teapot handle.

Here’s the “why” in plain language: the Redwork tool is trying to solve a pathing problem (a variation of the "Königsberg Bridge" math problem). If your segments don’t physically meet, Hatch sees a "dead end" and cannot treat them as a continuous network. You’ll get broken sequencing, weird jumps, or a Redwork object that simply doesn’t behave.

Pro tip from the comments (translated into a practical habit)

People love this feature because it rescues them when they’re “in trouble.” The fastest way to stay out of trouble is to digitize intersections on purpose—don’t hope two endpoints are “close enough.” Make them overlap by at least 1-2mm. You won't see this overlap in the final stitch out because it merges, but the software needs that overlap to function.

Apply the Hatch Redwork Tool (Ctrl+I): Select Everything, Then Pick One Start/End Point

Once you’ve digitized your outline segments, you’ll see multiple pieces in the sequence view.

Now do exactly what the tutorial shows (don't improvise here):

1) Select all digitized objects.

• You can drag a bounding box around everything.
• Or use Ctrl+A if only the design is on screen.

2) Click the Redwork icon, or use the shortcut Ctrl + I.

3) Click one point on the design to set the start/end.

Sue emphasizes a detail that calms a lot of confusion: in Redwork, the start and end point are the same point, so you only need to pick one. Make sure you pick a logical spot—usually the bottom of a design or an inconspicuous corner, just in case there is a tiny knot visible.

Expected outcome (What you should see)

• Visual Consolidation: Your many outline segments in the Sequence docker consolidate into one Redwork object.
• Pathing flows: The connector lines (dotted lines showing jumps) should disappear or drastically reduce.

If you don’t see that consolidation, STOP. Don’t keep clicking random points. Go back and check intersections (we’ll cover fixes below) because the software hasn't "glued" the pieces together yet.

Backstitch in Hatch Redwork: Get the Traditional Look Without Breaking the Double-Pass Logic

After creating the Redwork object, Sue shows how to change the stitch type:

• With the Redwork object selected, change from Single Run to Backstitch in the top toolbar.
  

Here’s the key nuance from the tutorial (and it’s a big one):

• The first pass remains a single run (think of it as the travel/foundation outline pass).
• The second pass becomes the stitch you chose (Backstitch in the demo).
• It is not “two layers of backstitch.”

That’s why the result stays consistent and still obeys the “exactly twice” Redwork rule. If it were two layers of backstitch, you would have four layers of thread by the end—a bulletproof vest, not a tea towel design.

Setup checklist (Before you export a stitch file)

• Object Check: Confirm the Redwork object is truly a single consolidated object (not multiple leftover segments).
• Stitch Type: Verify your chosen outline stitch type (e.g., Backstitch) is applied to the Redwork object.
• Run Preview: Use the "Stitch Player" to watch the route. Look for unexpected long travels across the middle of the design.
• Parameter Check: If using Backstitch, ensure Stitch Length is appropriate (standard is around 2.5mm - 3.0mm; 0.098 in to 0.11 in).
• Density Check: Ensure variable run length is checked to handle sharp corners.

The video shows stitch settings visible in the Object Properties panel, including Stitch Length 0.098 in, Min Length 0.049 in, and Variable run length checked.

“I Digitized Myself Into a Corner”: How to Let Hatch Calculate the Branching Instead of You

Sue openly mentions digitizing into a corner during the demo—and that’s a real-world moment every digitizer recognizes.

The troubleshooting guidance in the video is straightforward:

• If the design has complex branching, don’t manually plot the path.
• Focus on the one job you must do: make sure lines intersect, then let the Redwork tool calculate the route.

This is also where digitizing judgment matters. In general, branching areas (Celtic knots, handles, vines) benefit from:

• Slightly longer segments (fewer micro-pieces to manage).
• Clear, intentional crossovers.
• A quick preview after Redwork conversion to confirm the travel logic looks sane.

A commenter shared using Redwork on a Celtic knot for a pants pocket and said it made the job easy—this is exactly the kind of “branchy” design where the tool shines.

When Hatch Redwork Tool Won’t Sequence Correctly: Symptoms → Causes → Fixes

If the Redwork tool fails, it’s almost always because the geometry isn’t connected the way the algorithm needs. Use this troubleshooting table to diagnose the issue quickly.

Multi-Color “Redwork Style” Designs: How to Think About It Without Breaking Redwork Rules

A common question in the comments: “How do I digitize a Redwork style design that has multiple colors?” (e.g., A red teapot with blue steam).

The video teaches traditional Redwork rules (outline-only, stitched twice). It doesn’t show a multi-color workflow, but you can still think clearly about it:

• If you change thread colors, you’re no longer doing “single continuous Redwork” in the strictest sense because the machine must stop to let you change threads.
• What you can do is create multiple Redwork objects, one per color region.
  • Example: Select all the "Steam" lines -> Apply Redwork Tool (Blue).
  • Example: Select all the "Teapot" lines -> Apply Redwork Tool (Red).

In practice, execute each color group separately. Always preview the stitch-out to ensure the jumps between colors are logical and trim-friendly.

Software Compatibility Questions (EmbroideryStudio, Wilcom E4, MBX, PE-Design): What You Can Safely Assume

Several commenters asked whether this feature exists in other platforms (EmbroideryStudio, Wilcom E4, MBX/MBX V5, PE-Design).

The only safe takeaway from the thread is that availability depends on the software and vendor, and even the creator suggests checking with the manufacturer for updates. Wilcom (who powers Hatch) generally includes this "Branching" or "Redwork" logic in their higher-tier elements/levels, but terminology changes.

If you’re shopping software primarily for Redwork automation, treat this as your evaluation checklist:

• Does the software have a tool that converts connected open-shape segments into a continuous double-pass outline? (Often called "Branching").
• Can it keep Redwork logic intact when you switch outline stitch types?
• Does it provide a reliable stitch preview that shows the two-pass behavior clearly?

And yes—everyone has opinions about interface colors (the “lime green” comment made me laugh), but don’t let UI aesthetics distract you from the real question: can it produce predictable stitch files?

Decision Tree: Choosing Stabilizer for Redwork Stitch-Outs (Because Outlines Show Everything)

Even though the tutorial is software-focused, Redwork success is judged on fabric. Outlines are the hardest thing to stabilize because they don't grip the fabric like a fill stitch does.

Use this simple decision tree when you stitch your Redwork files:

(Start Here) What is your fabric?

• Stable Woven Cotton (Tea towels, Quilting cotton, Canvas):
  • Solution: Medium Tear-away.
  • Condition: If the fabric is thin/cheap, add spray adhesive to the stabilizer to prevent shifting.
  • Fix: If the outline puckers after 500 stitches, switch to Cut-away or create a tighter hoop.
• Stretchy Knit (T-shirts, Baby bodysuits):
  • Solution: Cut-away Mesh (No-Show Mesh).
  • Rule: Never use Tear-away on knits for outlines; the vibration will tear the stabilizer mid-stitch.
  • Extra: Use a water-soluble topper to keep the stitches from sinking into the knit ribs.
• Textured / Lofty (Fleece, Terry Towels):
  • Solution: Cut-away + Heavy Water Soluble Topper.
  • Action: Slow machine speed down (approx. 500 SPM). The needle needs time to penetrate the fluff without deflection.
• Pre-made Items with Seams (Pockets, Tote Bags):
  • Problem: Traditional hoops leave "hoop burn" or can't grip thick seams evenly.
  • Solution: This is where efficient tools matter. Many specific items benefit from the firm, even grip of a magnetic embroidery hoop. Magnetic frames hold thick seams without forcing you to wrench a thumbscrew, reducing the distortion that ruins outline alignment.

Warning: Magnetic frames are powerful industrial tools. They can pinch fingers severely if handled carelessly. Keep them away from pacemakers and implanted medical devices due to strong magnetic fields.

The Upgrade Path: When Redwork Becomes a Product, Not Just a Technique

Once you can digitize Redwork quickly, the software bottleneck is gone. The next bottleneck is usually production: hooping time, repeatability, and machine throughput.

Here’s a practical “tool upgrade” way to think about it based on your volume:

1. Level 1: The Hobbyist (Gifts & Personal Use)
   • Keep it simple. Focus on clean digitizing in Hatch and correct stabilizer matching.
   • Goal: Perfect quality, time is not an issue.
2. Level 2: The Side Hustle (Etsy Orders, 10-50 items)
   • Pain Point: Hand/Wrist fatigue from hooping; "Hoop Burn" marks requiring ironing/washing.
   • Upgrade: Reduce handling time. A hooping workflow upgrade like hooping stations can make placement repeatable (logo is always 3 inches down). For faster loading with less damage to delicate fabrics, consider shifting to magnetic embroidery hoops. Speeding up the loading process is often cheaper than buying a faster machine.
3. Level 3: The Production Shop (Corporate Orders, Team Gear)
   • Pain Point: Machine stops for thread changes; single needle limits.
   • Upgrade: Multi-needle efficiency. Many studios move to a multi-needle platform (like our SEWTECH multi-needle embroidery machines) when color changes and uptime become the limiting factor—because the best digitizing in the world can’t compensate for slow production.
   • Note: If you are stitching on Brother multi-needle machines, you will likely eventually look for a brother hat hoop or similar specialty fixture. Redwork on caps is difficult due to the curve—stability and repeatability allow the outline to meet perfectly where it started.

Final Run: What “Good” Looks Like When You Did Everything Right

When you follow the video’s method, your end result should look like the final teapot view: a clean outline design ready to stitch, with the Redwork logic intact.

Operation checklist (Right before you press 'Start')

• Pathing Preview: Run the simulator on the machine screen. Does every line get covered twice?
• Hidden Fills: Confirm there are no fill objects hiding in the file (check stitch count; Redwork is usually low stitch count).
• Consolidation: Check that the machine calculates it as one color stop (unless you designed multi-color).
• Stitch Logic: If you switched to Backstitch, confirm the first pass is still run stitch and the second pass is the chosen stitch.
• Test Sew: Stitch a small test on a scrap of similar fabric. Listen to the machine—a rhythmic, steady sound is good. A banging or laboring sound means your density is too high or stabilizer is too thick.

If you take only one lesson from Sue’s tutorial, make it this: don’t waste time manually plotting paths—spend that energy making sure your lines truly connect. That’s the difference between fighting the software and letting it do what it was built to do.

FAQ

• Q: In Hatch Embroidery Software 2.0, why does the Redwork Tool (Ctrl+I) fail to consolidate multiple Digitize Open Shape segments into one Redwork object?
  A: The Redwork Tool usually fails because at least one segment has an “air gap” and the lines are not truly touching, intersecting, or crossing.
  • Zoom in hard (a safe habit is extreme zoom, e.g., several hundred percent) and inspect every endpoint and junction.
  • Use Reshape to drag endpoints so they overlap slightly instead of “almost touching.”
  • Force a deliberate intersection at problem junctions (cross like an “X” if needed), then preview again.
  • Success check: After applying Ctrl+I, the Sequence view shows one consolidated Redwork object and dotted connector/jump lines mostly disappear.
  • If it still fails: Redraw the messy junction with fewer segments where many lines meet at one tiny point.
• Q: In Hatch Embroidery Software 2.0, how much overlap should Digitize Open Shape endpoints have so the Redwork Tool can calculate a continuous double-pass path?
  A: Intentionally overlap connected endpoints slightly (about 1–2 mm) so Hatch reads the network as connected.
  • Don’t rely on “close enough”; make the overlap deliberate at every intersection.
  • Reshape the start/end nodes to cross or sit on top of each other instead of leaving a hairline gap.
  • Re-apply the Redwork Tool only after all segments are physically connected.
  • Success check: Stitch Player shows a continuous route with minimal unexpected long travel lines across open space.
  • If it still fails: Hunt for one remaining “near miss” intersection—one missed junction can break the whole conversion.
• Q: In Hatch Embroidery Software 2.0 Redwork, why does changing the Redwork object to Backstitch not create two full passes of Backstitch?
  A: This is normal: Hatch Redwork keeps the first pass as a single run (foundation/travel) and applies the chosen stitch (like Backstitch) only on the second pass.
  • Select the consolidated Redwork object, then change the outline stitch type to Backstitch in the toolbar.
  • Use Stitch Player to watch the two-pass behavior instead of judging only from the object name.
  • Keep stitch settings reasonable for Backstitch (the tutorial shows ~0.098 in stitch length with variable run length enabled).
  • Success check: The preview clearly shows two passes on each line, with the first looking like a simple run and the second showing the Backstitch pattern.
  • If it still fails: Confirm the design is truly one Redwork object (not leftover separate segments) before changing stitch type.
• Q: In Hatch Embroidery Software 2.0 Digitize Open Shape, what click pattern helps keep Redwork curves smooth without creating too many nodes?
  A: Use the left-click/right-click rhythm from Digitize Open Shape to control corners vs curves and avoid “jittery” outlines.
  • Left click to place straight corner points; right click to place curved points.
  • Press Enter to finish each segment, then start the next segment where it must connect.
  • Avoid micro-clicking on curves; a safe beginner target is fewer, intentional nodes rather than dense node clusters.
  • Success check: The on-screen outline looks smooth (not faceted), and the stitched line does not look choppy or shaky.
  • If it still fails: Redraw only the problem curve with fewer nodes, then re-apply the Redwork Tool.
• Q: When stitching Hatch Embroidery Software 2.0 Redwork on stretchy knit T-shirts, what stabilizer and topper combination prevents outline puckering and sinking?
  A: Use cut-away mesh (no-show mesh) underneath and a water-soluble topper on top to keep Redwork outlines clean on knits.
  • Hoop the knit with cut-away mesh so the fabric cannot “walk” during the double-pass.
  • Add water-soluble topper to prevent the outline from sinking into knit ribs.
  • Stitch a small test sample first, because outlines reveal movement immediately.
  • Success check: The line looks bold and even after the second pass, with minimal waviness and no tunneling/puckering around the outline.
  • If it still fails: Re-check hooping tightness and consider switching away from tear-away (tear-away on knits often fails for outline-only work).
• Q: What needle and prep consumables are a safe starting point for Hatch Embroidery Software 2.0 Redwork stitch-outs to reduce snags during double-pass outlines?
  A: Start with a fresh sharp needle and simple marking/support tools, because Redwork double-passes can exaggerate snags and deflection.
  • Install a fresh sharp needle (the tutorial mentions Organ 75/11 as a common choice for standard cotton).
  • Keep a water-soluble pen ready for physical marking and placement checks before stitching.
  • Confirm the design is truly outline-only (no hidden fills) before committing to fabric.
  • Success check: The machine runs with a steady sound and the outline looks clean, without repeated snag points on the second pass.
  • If it still fails: Re-test on a scrap with the same fabric + stabilizer combo to isolate whether the issue is digitizing geometry or fabric handling.
• Q: What needle-area safety rule should beginners follow when test-stitching fast Redwork designs on an embroidery machine?
  A: Keep fingers completely clear of the needle and never reach under the presser foot while the machine is running, because Redwork moves and changes direction quickly.
  • Stop the machine before adjusting fabric, thread, or stabilizer.
  • Keep hands outside the hoop travel area during rapid direction changes.
  • Use the machine’s preview/simulator first so fewer “surprise moves” happen during stitching.
  • Success check: Hands never enter the needle/presser-foot zone while stitching is active, even during quick tests.
  • If it still fails: Slow down, pause more often, and reposition hands before restarting—speed is never worth a finger injury.
• Q: For outline-only Redwork production, when should an embroidery shop upgrade from technique fixes to magnetic embroidery hoops or a multi-needle machine for throughput?
  A: Upgrade based on the bottleneck: first fix digitizing and stabilization, then improve hooping speed/consistency, and only then consider multi-needle throughput when stops become the limiter.
  • Level 1 (technique): Tighten Redwork geometry (connected lines) and match stabilizer to fabric so outlines stop showing wobble.
  • Level 2 (tooling): If hooping causes wrist fatigue, slow loading, or hoop burn on delicate/pre-made items, magnetic embroidery hoops and repeatable placement workflows can reduce handling time.
  • Level 3 (capacity): If frequent thread changes and uptime are limiting order volume, a multi-needle platform is often the next step after workflow is stable.
  • Success check: The shop sees fewer redo pieces from misalignment/hoop marks, and per-item cycle time drops in a measurable way.
  • If it still fails: Track where time is actually lost (digitizing vs hooping vs color-change downtime) before buying hardware—solve the biggest delay first.