Jetendard: a JetBrainsMono Nerd Font Mono with Pretendard Hangul glyphs

The Hangul-in-a-monospace-cell problem

Monospace programming fonts are designed around Latin advance widths. Korean text does not fit that assumption. Hangul syllables are drawn as full-width blocks, so when a Latin-first monospace font is asked to render Korean, the result is either glyphs that overflow the cell or glyphs that sit inside it with visible slack on both sides. The slack is what breaks reading rhythm: a Korean word appears to drift apart, and mixed Korean and English lines look like two different typefaces sharing a baseline.

Jetendard is aimed at people who write Korean source comments, commit messages, terminal output or documentation inside a monospace environment. The README frames the goal narrowly: Korean and CJK glyphs are fitted into exactly two Latin monospace advances. That is the whole design contract. A Hangul syllable occupies two Latin cells, which is the convention most Korean developers already expect from terminal emulators and editors that do double-width handling.

The project is a build pipeline, not a hand-edited font. The README says it is heavily inspired by Yeomil Mono and reuses much of that implementation with minimal changes. The two substitutions are the base Latin face and the Korean source: JetBrainsMono Nerd Font Mono replaces Geist Mono, and Pretendard replaces whatever Yeomil Mono used. That lineage matters when you are deciding whether to trust the output, because the fitting logic is inherited rather than written from scratch here.

How the merge works: two Latin advances, one 1.15 scale

The generated family is named Jetendard. Latin glyphs, programming ligatures and Nerd Font symbols come from the ligature-enabled JetBrainsMonoNerdFontMono files. Korean and CJK glyphs come from Pretendard and are fitted into exactly two Latin monospace advances. The default Korean scale is 1.15, applied through the --korean-scale option, with --scale kept as a compatibility alias.

The README gives the reasoning for that number directly: slightly enlarging Pretendard reduces unnecessary spacing around Korean glyphs, which makes Korean word spacing feel more visually stable and improves Hangul rendering clarity. This is a typographic judgement rather than a measured result, and the README does not publish a comparison table or metrics to back it. Treat 1.15 as the author's chosen default, not a derived optimum.

The scope is deliberately narrow. Jetendard only uses JetBrainsMonoNerdFontMono. It does not use JetBrainsMonoNerdFont, JetBrainsMonoNerdFontPropo, or the JetBrainsMonoNL no-ligature variants. Because the base font is already Nerd Font patched, the project does not run a second Nerd Fonts patching step. That saves build time and avoids the glyph duplication that a second patch pass can introduce, but it also means you cannot swap in a different Nerd Font base without editing the pipeline.

Variant coverage follows the pinned Nerd Fonts archive. The README's table lists eight weights (Thin through ExtraBold) in upright and italic, sixteen files total. Pretendard-Black is not built by default because the confirmed JetBrainsMonoNerdFontMono archive has no matching Black source. The downloader still extracts PretendardVariable.ttf when available, which the README describes as groundwork for future custom-weight work rather than a working feature.

Building Jetendard with uv and make

The project requires Python 3.12 or newer and uses uv for dependency management. The README's build sequence is four commands. The first installs every dependency group, the second fetches upstream fonts, the third builds, and the fourth runs the test suite.

uv sync --all-groups
make download
make run
make test

make run builds the full 16-variant family. It depends on the ensure-upstream target, which checks for the upstream/jetbrainsmono and upstream/pretendard directories and runs make download automatically if either is missing. So in practice you can skip make download on a first run and let the dependency pull it in, though running it explicitly makes the download step visible.

Generated files land in three directories. TrueType files go to fonts/ttf/Jetendard-*.ttf, OpenType files to fonts/otf/Jetendard-*.otf, and web fonts to fonts/webfont/Jetendard-*.woff2 alongside fonts/webfont/jetendard.css. The README notes that generated outputs and upstream downloads are intentionally ignored by git, so a fresh clone has no fonts until you build them.

If you only want a few faces rather than all sixteen, the CLI takes explicit selections. This example builds the upright and italic forms of two weights:

uv run jetendard --weights Regular Bold --styles normal italic

The README also lists --variants for naming output variants directly, such as Regular, Italic or BoldItalic, and --korean-italic-mode with its current value upright. Running uv run jetendard --help prints the full option list. For a lighter first build, make run-minimal maps to --variants Regular Light Bold.

Italic Korean is upright, and the metadata says otherwise

The clearest limitation is in the italic variants. Pretendard does not provide true static italic Korean or CJK fonts in the pinned archive, so italic Jetendard variants pair italic JetBrainsMono Latin glyphs with upright Pretendard Korean glyphs. The generated font metadata and CSS still identify those variants as italic.

That is a real mismatch, not a cosmetic note. A Korean word inside an italic comment will not slant, while the English around it will. In a code review or a diff, the two scripts will look like they came from different fonts, because in effect they did. The README documents this openly and offers --korean-italic-mode with upright as the only current value, which means there is no oblique or synthetic-slant option to switch to today.

The second limitation is weight coverage. Anyone who uses Black for headings or display text will not find it here, and the README explains why rather than promising a fix. The third is the build requirement itself. There is no prebuilt binary in the repository and no documented release archive procedure beyond a manual step: release archives can be prepared from the font directories after a manual visual pass confirms the default Korean scale across upright and italic variants. If you need a font file in thirty seconds, this is the wrong tool. Fonts that ship as static downloads will always win that comparison.

A fourth point is honest but easy to miss: the 1.15 scale is a single global value. If your renderer at your point size makes Korean look too large or too tight, the answer is to rebuild with a different --korean-scale, not to adjust anything at runtime. The README's visual check samples exist for exactly that comparison, and it asks you to hold renderer, point size and line height constant when comparing against Yeomil Mono or another monospace baseline.

Jetendard compared with Yeomil Mono

The obvious alternative is Yeomil Mono, the project Jetendard credits as its inspiration and implementation source. The difference is the Latin base. Yeomil Mono builds on Geist Mono; Jetendard builds on JetBrainsMono Nerd Font Mono.

That single substitution changes several things at once. JetBrains Mono is designed for code, with a taller x-height and programming ligatures, and the Nerd Font Mono build adds icon glyphs for terminal prompts and editor status lines. Geist Mono has a different skeleton and a different set of ligature decisions. Neither is better in the abstract; they read differently, and the one you already have configured in your editor is probably the one you should keep. If you are switching to Jetendard specifically for the Korean rendering, you are also accepting a change in how all your Latin code looks.

The second difference is the 1.15 Pretendard scale, which the README presents as Jetendard's own adjustment relative to Yeomil Mono. Since both projects fit Korean into two Latin advances, the fitting rule is shared; the scale is where they diverge. That makes the two projects easy to compare side by side with the README's sample text, using the same renderer settings.

If your actual requirement is a different base font entirely, neither project helps. Jetendard's scope section is explicit that it uses only JetBrainsMonoNerdFontMono, so there is no configuration flag for swapping the Latin source. You would be forking the pipeline, not configuring it.

Licence, attribution and the cost of staying current

Jetendard is distributed under the SIL Open Font License 1.1, and the repository carries a LICENSE file. The README also directs readers to review the upstream JetBrains Mono, Nerd Fonts, Pretendard and Yeomil Mono projects for their full copyright and reserved-name notices.

That instruction is doing real work. A merged font carries the licence obligations of every source it draws from, and the OFL has a reserved font name mechanism that constrains how modified versions may be named. Because Jetendard combines at least four upstream projects, anyone redistributing the built files or shipping them inside a product should read those notices rather than assuming the single LICENSE file settles everything. This is not legal advice, and the README does not attempt to resolve the question either.

The version string in pyproject.toml is 0.1.0, matching the v0.1.0 release, and the last push to the repository was on 2026-07-07. There is no changelog in the repository listing, so upgrade cost is hard to estimate from what the README and repository files describe. In practice the upgrade path is a rebuild: you pull the repository, run uv sync --all-groups and make run again, and compare the output against your previous files. Because the upstream fonts are pinned, a rebuild should be reproducible, but the README does not state how or where the pin is recorded, so confirming that is on you.

The maintenance surface is small. The project is Python with two runtime dependencies, brotli and fonttools, plus ruff and pytest in the lint and test groups. There is no server, no daemon and no runtime component. The cost of adopting Jetendard is almost entirely front-loaded into the first build and the visual check; after that, it is a set of font files that either work in your editor or do not.

Editorial conclusion

Adopt Jetendard if you write Korean inside a monospace editor or terminal and want Nerd Font symbols and JetBrains Mono ligatures in the same face. Skip it if you need true italic Hangul, a Black weight, or a font you can install without running a build. Verify the 1.15 Korean scale on your own renderer at your own point size before packaging a release, because the README treats that visual pass as a manual gate.

Frequently asked questions

Official sources

1. Issues
2. kuskhan/jetendard on GitHub
3. README
4. Releases