JEF File Documentation

---

Technical details

Feature	Value
Full name	Janome Embroidery File
File extension	.jef (enhanced variant .jef+)
MIME type	application/octet-stream
Format type	Proprietary binary machine-embroidery stitch file
Developer	Janome (Janome Sewing Machine Co.)
Also used by	Elna machines (made by Janome)
Introduced	Late 1990s
Design model	Stitch-based (finished needle points), not outline/object
Byte order	Little-endian
Header size	Roughly 1440 bytes before the stitch list (offset in header)
Magic number	None documented — identified by structure and extension
Stitch encoding	2-byte signed (x, y) deltas; 0x80 introduces a 4-byte command
Coordinate units	0.1 mm per unit
Colour data	Thread (needle) list with colour-change sequence
Open standard	No — proprietary, reverse-engineered by libembroidery
Free viewer	Wilcom TrueSizer; Embrilliance Express; online viewers
Editors	Janome Digitizer, Embird, Embrilliance
Related extensions	.jef+, .sew, .dst, .pes, .exp, .vp3, .hus
Specification	janome.com (closed); community docs on KDE Liberty wiki

What is a JEF file?

A .jef file is a Janome Embroidery File, the native stitch-data format of Janome home embroidery machines, introduced in the late 1990s and also used by Elna machines (Janome manufactures Elna's embroidery hardware). It does not store a picture in the ordinary sense. It stores the physical path the needle takes: an ordered list of stitch coordinates and machine commands, plus a header recording the design's size, hoop and thread colours. The machine reads this and stitches the design onto fabric.

JEF is a stitch format, not an outline or object format. It records the finished stitches themselves, so unlike a digitizing project it carries no editable shapes and can be scaled only slightly before the stitch density distorts. This is the key mental model for the format and it explains most of what follows, including why “resize this design” is harder than it sounds and why converting to another machine's format is a stitch-for-stitch translation rather than a re-render.

Stitch data versus outline data

Embroidery formats fall into two camps. Outline (object) formats keep the digitized shapes, stitch types and parameters, so software can regenerate the stitches at any size. Stitch formats keep only the computed result: the exact needle penetrations. JEF is firmly in the stitch camp, alongside DST, PES (in its stitch portion), EXP and VP3. The practical consequence is density. Stitches were laid down for one physical size; enlarge the design 150% and the same number of stitches spreads over more fabric, thinning the fill, while shrinking it packs stitches until they pile up and jam. Small adjustments (a few percent) are fine; substantial resizing needs the original outline design or a re-digitize, not a stitch file.

The JEF file layout: header, thread list, stitch list

A JEF file is a binary stream in little-endian byte order, arranged in sections. There is no signature constant at the start; instead the header opens with an offset to the stitch data, and a reader uses that offset to know where the fixed header and thread tables end and the stitch records begin. The header region is roughly 1440 bytes.

JEF file sections (in order)
 ┌─ Header
 │   ├─ stitch-data offset      (little-endian; where the stitch list starts)
 │   ├─ format / version flags
 │   ├─ design width / height   (bounding box, 0.1 mm units)
 │   ├─ hoop code               (which Janome hoop the design targets)
 │   └─ colour (thread) count
 ├─ Thread list                 ordered thread/needle colours + change sequence
 ├─ Embedded bitmaps            small preview thumbnails at fixed offsets
 └─ Stitch list                 the (dx, dy) stitch and command records

The stored width and height are the design's bounding box, used by the machine to check the design fits the selected hoop. The hoop code matters in practice: a Janome machine refuses a design flagged for a hoop larger than the one fitted, which is one common reason a valid .jef “won't load.” The header also carries small embedded preview bitmaps at fixed offsets (reverse-engineering work places monochrome and per-colour thumbnails at offsets such as 0x004A and 0x010C), which let a machine or viewer show the design before stitching.

The thread list and colour changes

Before the stitches, JEF stores an ordered thread list: one entry per colour block, in stitching order, describing the thread colour and referencing a Janome thread palette. This list is what a viewer reads to show the design in colour and what the machine uses to tell you which thread to load at each stop. The number of entries matches the colour count in the header. Because the colours are an explicit ordered list rather than embedded per stitch, converting JEF to a format that carries no colour data, such as DST, loses this information: DST records only stitches and stops, so the operator must re-assign colours afterwards.

Stitch records and the 0x80 command escape

The stitch list is a sequence of short records. A normal stitch is two signed bytes, a relative move (dx, dy) from the previous point, each in the range −127 to +127, in units of 0.1 mm. Storing deltas rather than absolute positions keeps each stitch to two bytes and matches how the machine actually moves the hoop: step the frame by (dx, dy), drop the needle, repeat.

Normal stitch:   [dx] [dy]           dx, dy signed, 0.1 mm units
Command escape:  [0x80] [code] [dx] [dy]   4 bytes, when x byte == 0x80 (-128)
   code 0x01/0x02 …  colour change / stop
   code (jump)       move without stitching (long travel)
   code (trim)       cut the thread
End of design:   [0x80] [0x10]        terminates the stitch list

The value 0x80 (−128) never occurs as a legitimate stitch delta, so it is reused as an escape. When the x byte equals 0x80, the record is a 4-byte command: 0x80, a command code, then a (dx, dy) pair for the associated move. The command code selects a colour change (advance to the next thread in the list), a jump (reposition the hoop without stitching, used to travel between separated areas), or a trim (cut the thread). The design ends with the special two-byte sequence 0x80 0x10. A reader decodes the whole design by walking these records, accumulating an absolute needle position from the deltas and acting on each command in turn.

JEF+ and the format variants

Janome later introduced JEF+ for newer machines, an enhanced variant that adds sections beyond the base header and stitch list (extra design and editing data), and some files carry the .jef+ name. A machine expecting one variant may reject the other, which is another cause of load failures: a plain-JEF machine and a JEF+ file, or the reverse, will not agree. Embroidery software that writes JEF lets you pick the target variant and hoop so the output matches the specific machine.

Viewing, converting and loading onto the machine

To simply preview a design, the free Wilcom TrueSizer opens JEF and shows the stitches, thread colours and dimensions, as do Embrilliance Express and browser-based embroidery viewers. To edit or convert, an embroidery editor that reads JEF and writes other stitch formats, Embird or Embrilliance, exports to PES (Brother/Baby Lock), DST (near-universal Tajima), VP3 (Husqvarna Viking/Pfaff) or EXP (Melco/Bernina). Keep the original physical size when converting, for the density reasons above. One request is effectively pointless: exporting JEF to a vector format such as SVG produces a messy stitch trace, not clean editable outlines, because the file only ever held finished stitches. To stitch the design, copy the .jef to the USB stick or card exactly as the machine's manual specifies, in a hoop size the machine accepts.

References

• Janome — Embroidery Formats (official)
• KDE Liberty — Janome Embroidery Format (reverse-engineered structure)
• Wilcom TrueSizer — free embroidery viewer/converter

Feedback

Was this page helpful?

Yes No

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.