diff --git a/README.md b/README.md
index 6de9c8f..11f9311 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ If you'd like to see a vectorized version of this font, try [Miracode](https://g
 
 ### Windows
 
-Download the most recent `Monocraft.ttf` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Right click on the downloaded font and select **Install**. You might need administrative access to install fonts, depending on your machine.
+Download the most recent `Monocraft.ttc` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Right click on the downloaded font and select **Install**. You might need administrative access to install fonts, depending on your machine.
 
 ### Mac
 
@@ -48,11 +48,11 @@ brew install --cask font-monocraft
 
 #### Manually
 
-Download the most recent `Monocraft.ttf` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Double click on the downloaded font file and select **Install Font** in the window that appears. More help available [here](https://support.apple.com/en-us/HT201749).
+Download the most recent `Monocraft.ttc` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Double click on the downloaded font file and select **Install Font** in the window that appears. More help available [here](https://support.apple.com/en-us/HT201749).
 
 ### Linux
 
-Download the most recent `Monocraft.ttf` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Move the file to ~/.local/share/fonts (create the folder if it doesn't already exist). In a terminal, run `fc-cache -fv`. Alternatively, log out and log in again. 
+Download the most recent `Monocraft.ttc` file from the [Releases](https://github.com/IdreesInc/Monocraft/releases) page. Move the file to ~/.local/share/fonts (create the folder if it doesn't already exist). In a terminal, run `fc-cache -fv`. Alternatively, log out and log in again. 
 
 ## How to use
 
@@ -80,4 +80,4 @@ I've got you covered, check out my rendition of the Minecraft typeface [here](ht
 
 ### What if I want to use a font that's actually good?
 
-Understandable, check out [Fira Code](https://github.com/tonsky/FiraCode) for a font with amazing attention to detail, or [Scientifica](https://github.com/nerdypepper/scientifica) for a bitmap font similar to this.
+Understandable, check out [Fira Code](https://github.com/tonsky/FiraCode) for a font with amazing attention to detail, or [Scientifica](https://github.com/nerdypepper/scientifica) for a bitmap font similar to this. Feel free to also check out my font [Miracode](https://github.com/IdreesInc/Miracode) for a font based on Monocraft that's a little more usable!
\ No newline at end of file
diff --git a/examples/glyphs.txt b/examples/glyphs.txt
index 0325540..f07459a 100644
--- a/examples/glyphs.txt
+++ b/examples/glyphs.txt
@@ -8,9 +8,9 @@ a b c d e f g h i j k l m n o p q r s t u v w x y z
 ! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~ 
 ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ 
 Ò Ó Ô Õ Ö × Ø Ù Ú Û Ü Ý Þ ß à á â ã ä å æ ç è é ê ë ì í î ï ð ñ ò ó ô õ ö ÷ ø ù ú û ü ý þ ÿ Ā ā 
-Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď Ē ē Ĕ ĕ Ė ė Ę ę Ě ě Ĝ ĝ Ğ ğ Ġ ġ Ģ ģ Ĥ ĥ Ĩ ĩ Ī ī Ĭ ĭ İ IJ ij Ĵ ĵ Ķ ķ ĸ 
-Ĺ ĺ Ļ ļ Ľ ľ Ł ł Ń ń Ņ ņ Ň ň Ō ō Ŏ ŏ Ő ő Œ œ Ŕ ŕ Ř ř Ś ś Ŝ ŝ Ş ş Š š Ť ť Ũ ũ Ū ū Ŭ ŭ Ů ů Ű ű Ŵ ŵ 
-Ŷ ŷ Ÿ Ź ź Ż ż Ž 
+Ă ă Ą ą Ć ć Ĉ ĉ Ċ ċ Č č Ď ď Ē ē Ĕ ĕ Ė ė Ę ę Ě ě Ĝ ĝ Ğ ğ Ġ ġ Ģ ģ Ĥ ĥ Ĩ ĩ Ī ī Ĭ ĭ İ ı IJ ij Ĵ ĵ Ķ ķ 
+ĸ Ĺ ĺ Ļ ļ Ľ ľ Ł ł Ń ń Ņ ņ Ň ň Ō ō Ŏ ŏ Ő ő Œ œ Ŕ ŕ Ř ř Ś ś Ŝ ŝ Ş ş Š š Ť ť Ũ ũ Ū ū Ŭ ŭ Ů ů Ű ű Ŵ 
+ŵ Ŷ ŷ Ÿ Ź ź Ż ż Ž 
 
 ž ſ Ɓ Ƅ ƅ Ɔ Ɖ Ǝ Ə Ɛ Ƒ ƚ ƛ ƞ Ɵ Ƨ ƨ Ʃ ƪ Ʋ Ʒ Ƹ ƹ ƻ Ƽ ƽ ƾ ƿ ǀ ǁ ǂ ǃ lj Ǎ ǎ Ǐ ǐ Ǒ ǒ Ǔ ǔ ǝ Ǣ ǣ Ǧ ǧ Ǩ ǩ 
 Ǯ ǯ ǰ Ǵ ǵ Ƿ Ǹ ǹ Ǽ ǽ Ș ș Ț ț Ȝ ȝ Ȟ ȟ Ƞ ȡ Ȥ ȥ Ȧ ȧ Ȯ ȯ Ȳ ȳ ȴ ȵ ȶ Ⱥ Ȼ ȼ Ƚ Ⱦ Ɂ ɂ Ƀ Ʉ Ʌ Ɇ ɇ Ɉ ɉ Ɋ ɋ Ɍ 
@@ -51,6 +51,7 @@ a b c d e f g h i j k l m n o p q r s t u v w x y z
  - >     ->     ->
  = >     ->     =>
  < = >    ->     <=>
+ < ! - -   ->     <!--
  = = >    ->     ==>
  = = = >   ->     ===>
  = = = = >  ->     ====>
diff --git a/src/characters.json b/src/characters.json
index 5da2650..a9fc414 100644
--- a/src/characters.json
+++ b/src/characters.json
@@ -2207,6 +2207,22 @@
 		],
 		"leftMargin": -0.5
 	},
+	{
+		"character": "ı",
+		"name": "latin_small_letter_dotless_i",
+		"codepoint": 305,
+		"pixels": [
+			[0, 0, 0, 0, 0],
+			[0, 0, 0, 0, 0],
+			[0, 0, 0, 0, 0],
+			[0, 1, 1, 0, 0],
+			[0, 0, 1, 0, 0],
+			[0, 0, 1, 0, 0],
+			[0, 0, 1, 0, 0],
+			[0, 0, 0, 1, 1]
+		],
+		"leftMargin": -0.5
+	},
 	{
 		"character": "ĵ",
 		"name": "latin_small_letter_j_with_circumflex",
diff --git a/src/ligatures.json b/src/ligatures.json
index c72dee2..bf10bfa 100644
--- a/src/ligatures.json
+++ b/src/ligatures.json
@@ -149,5 +149,19 @@
 			[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
 			[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
 		]
+    },
+    {
+        "ligature": "<!--",
+        "name": "html comment",
+        "sequence": [60, 33, 45, 45],
+        "pixels": [
+			[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+			[0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+			[0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+			[1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+			[0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+			[0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+			[0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+		]
     }
 ]
diff --git a/src/monocraft.py b/src/monocraft.py
index a193995..5421b8e 100644
--- a/src/monocraft.py
+++ b/src/monocraft.py
@@ -1,5 +1,5 @@
 # Monocraft, a monospaced font for developers who like Minecraft a bit too much.
-# Copyright (C) 2022-2023 Idrees Hassan
+# Copyright (C) 2022-2024 Idrees Hassan
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -17,10 +17,11 @@
 import fontforge
 import json
 import math
+import argparse
 from generate_diacritics import generateDiacritics
 from generate_examples import generateExamples
 from polygonizer import PixelImage, generatePolygons
-from generate_continuous_ligatures import generate_continuous_ligatures 
+from generate_continuous_ligatures import generate_continuous_ligatures
 
 PIXEL_SIZE = 120
 
@@ -32,50 +33,220 @@
 characters = generateDiacritics(characters, diacritics)
 charactersByCodepoint = {}
 
-def generateFont():
-	monocraft = fontforge.font()
-	monocraft.fontname = "Monocraft"
-	monocraft.familyname = "Monocraft"
-	monocraft.fullname = "Monocraft"
-	monocraft.copyright = "Idrees Hassan, https://github.com/IdreesInc/Monocraft"
-	monocraft.encoding = "UnicodeFull"
-	monocraft.version = "3.0"
-	monocraft.weight = "Regular"
-	monocraft.ascent = PIXEL_SIZE * 8
-	monocraft.descent = PIXEL_SIZE
-	monocraft.em = PIXEL_SIZE * 9
-	monocraft.upos = -PIXEL_SIZE # Underline position
-	monocraft.addLookup("ligatures", "gsub_ligature", (), (("liga",(("dflt",("dflt")),("latn",("dflt")))),))
-	monocraft.addLookupSubtable("ligatures", "ligatures-subtable")
+def parseArgs():
+	parser = argparse.ArgumentParser()
+	parser.add_argument(
+		"--output-ttc",
+		action="store_true",
+		dest="output_ttc",
+	)
+	parser.add_argument(
+		"-a",
+		"--all",
+		action="store_true",
+		dest="all",
+	)
+	parser.add_argument(
+		"-O",
+		"--black",
+		action="store_true",
+		dest="black",
+	)
+	parser.add_argument(
+		"-B",
+		"--bold",
+		action="store_true",
+		dest="bold",
+	)
+	parser.add_argument(
+		"-b",
+		"--semibold",
+		action="store_true",
+		dest="semibold",
+	)
+	parser.add_argument(
+		"-l",
+		"--light",
+		action="store_true",
+		dest="light",
+	)
+	parser.add_argument(
+		"-L",
+		"--extralight",
+		action="store_true",
+		dest="extralight",
+	)
+	parser.add_argument(
+		"-i",
+		"--italic",
+		action="store_true",
+		dest="italic",
+	)
+	ret = parser.parse_args()
+	if ret.all:
+		ret.black = ret.bold = ret.semibold = ret.light = ret.extralight = ret.italic = True
+	return ret
+
+def generateFont(*, black=False, bold=False, semibold=False, light=False, extralight=False, italic=False, output_ttc=False, **kw):
+	fontList = [
+		fontforge.font(),
+		fontforge.font() if italic else None,
+		fontforge.font() if black else None,
+		fontforge.font() if black and italic else None,
+		fontforge.font() if bold else None,
+		fontforge.font() if bold and italic else None,
+		fontforge.font() if semibold else None,
+		fontforge.font() if semibold and italic else None,
+		fontforge.font() if light else None,
+		fontforge.font() if light and italic else None,
+		fontforge.font() if extralight else None,
+		fontforge.font() if extralight and italic else None,
+	]
+	for font in fontList:
+		if font is None:
+			continue
+		font.fontname = "Monocraft"
+		font.familyname = "Monocraft"
+		font.fullname = "Monocraft"
+		font.copyright = "Idrees Hassan, https://github.com/IdreesInc/Monocraft"
+		font.encoding = "UnicodeFull"
+		font.version = "4.0"
+		font.weight = "Regular"
+		font.ascent = PIXEL_SIZE * 8
+		font.descent = PIXEL_SIZE
+		font.em = PIXEL_SIZE * 9
+		font.upos = -PIXEL_SIZE  # Underline position
+		font.addLookup("ligatures", "gsub_ligature", (),
+					   (("liga", (("dflt", ("dflt")), ("latn", ("dflt")))), ))
+		font.addLookupSubtable("ligatures", "ligatures-subtable")
+
+	font = fontList[0]
+	if font is not None:
+		font.macstyle = 0
+		font.os2_stylemap = 0x40
+	font = fontList[1]
+	if font is not None:
+		font.fontname = "Monocraft-Italic"
+		font.fullname = "Monocraft Italic"
+		font.macstyle = 2
+		font.os2_stylemap = 1
+		font.italicangle = -15
+	font = fontList[2]
+	if font is not None:
+		font.fontname = "Monocraft-Black"
+		font.fullname = "Monocraft Black"
+		font.weight = "Black"
+		font.macstyle = 1
+		font.os2_stylemap = 0x20
+	font = fontList[3]
+	if font is not None:
+		font.fontname = "Monocraft-Black-Italic"
+		font.fullname = "Monocraft Black Italic"
+		font.weight = "Black"
+		font.macstyle = 3
+		font.os2_stylemap = 0x21
+		font.italicangle = -15
+	font = fontList[4]
+	if font is not None:
+		font.fontname = "Monocraft-Bold"
+		font.fullname = "Monocraft Bold"
+		font.weight = "Bold"
+		font.macstyle = 1
+		font.os2_stylemap = 0x20
+	font = fontList[5]
+	if font is not None:
+		font.fontname = "Monocraft-Bold-Italic"
+		font.fullname = "Monocraft Bold Italic"
+		font.weight = "Bold"
+		font.macstyle = 3
+		font.os2_stylemap = 0x21
+		font.italicangle = -15
+	font = fontList[6]
+	if font is not None:
+		font.fontname = "Monocraft-SemiBold"
+		font.fullname = "Monocraft SemiBold"
+		font.weight = "Demi"
+		font.macstyle = 1
+		font.os2_stylemap = 0x20
+	font = fontList[7]
+	if font is not None:
+		font.fontname = "Monocraft-SemiBold-Italic"
+		font.fullname = "Monocraft SemiBold Italic"
+		font.weight = "Demi"
+		font.macstyle = 3
+		font.os2_stylemap = 0x21
+		font.italicangle = -15
+	font = fontList[8]
+	if font is not None:
+		font.fontname = "Monocraft-Light"
+		font.fullname = "Monocraft Light"
+		font.weight = "Light"
+		font.macstyle = 0
+		font.os2_stylemap = 0
+	font = fontList[9]
+	if font is not None:
+		font.fontname = "Monocraft-Light-Italic"
+		font.fullname = "Monocraft Light Italic"
+		font.weight = "Light"
+		font.macstyle = 2
+		font.os2_stylemap = 1
+		font.italicangle = -15
+	font = fontList[10]
+	if font is not None:
+		font.fontname = "Monocraft-ExtraLight"
+		font.fullname = "Monocraft ExtraLight"
+		font.weight = "Extra-Light"
+		font.macstyle = 0
+		font.os2_stylemap = 0
+	font = fontList[11]
+	if font is not None:
+		font.fontname = "Monocraft-ExtraLight-Italic"
+		font.fullname = "Monocraft ExtraLight Italic"
+		font.weight = "Extra-Light"
+		font.macstyle = 2
+		font.os2_stylemap = 1
+		font.italicangle = -15
 
 	for character in characters:
 		charactersByCodepoint[character["codepoint"]] = character
-		monocraft.createChar(character["codepoint"], character["name"])
-		pen = monocraft[character["name"]].glyphPen()
-		top = 0
-		drawn = character
-
 		image, kw = generateImage(character)
-		drawImage(image, pen, **kw)
-		monocraft[character["name"]].width = PIXEL_SIZE * 6
+		createChar(fontList, character["codepoint"], character["name"], image, **kw)
 	print(f"Generated {len(characters)} characters")
 
 	outputDir = "../dist/"
 	if not os.path.exists(outputDir):
 		os.makedirs(outputDir)
 
-	monocraft.generate(outputDir + "Monocraft-no-ligatures.ttf")
+	if output_ttc:
+		fontList[0].generateTtc(
+			outputDir + "Monocraft-no-ligatures.ttc",
+			[i for i in fontList[1:] if i is not None],
+			ttcflags=("merge", ),
+			layer=1,
+		)
+
 	for ligature in ligatures:
-		lig = monocraft.createChar(-1, ligature["name"])
-		pen = monocraft[ligature["name"]].glyphPen()
 		image, kw = generateImage(ligature)
-		drawImage(image, pen, **kw)
-		monocraft[ligature["name"]].width = PIXEL_SIZE * len(ligature["sequence"]) * 6
-		lig.addPosSub("ligatures-subtable", tuple(map(lambda codepoint: charactersByCodepoint[codepoint]["name"], ligature["sequence"])))
+		createChar(fontList, -1, ligature["name"], image, width=PIXEL_SIZE * len(ligature["sequence"]) * 6, **kw)
+		for font in fontList:
+			if font is None:
+				continue
+			font[ligature["name"]].addPosSub("ligatures-subtable", tuple(map(lambda codepoint: charactersByCodepoint[codepoint]["name"], ligature["sequence"])))
 	print(f"Generated {len(ligatures)} ligatures")
 
-	monocraft.generate(outputDir + "Monocraft.ttf")
-	monocraft.generate(outputDir + "Monocraft.otf")
+	for font in fontList:
+		if font is None:
+			continue
+		font.generate(f"{outputDir}{font.fontname}.otf")
+		font.generate(f"{outputDir}{font.fontname}.ttf")
+
+	if output_ttc:
+		fontList[0].generateTtc(
+			outputDir + "Monocraft.ttc",
+			[i for i in fontList[1:] if i is not None],
+			ttcflags=("merge", ),
+			layer=1,
+		)
 
 def generateImage(character):
 	image = PixelImage()
@@ -116,15 +287,15 @@ def imageFromArray(arr, x=0, y=0):
 		y=y,
 		width=len(arr[0]),
 		height=len(arr),
-		data=bytes(x for a in reversed(arr) for x in a),
+		data=bytes(v for a in reversed(arr) for v in a),
 	)
 
-def drawImage(image, pen, *, dx=0, dy=0):
-	for polygon in generatePolygons(image):
+def drawPolygon(poly, pen):
+	for polygon in poly:
 		start = True
 		for x, y in polygon:
-			x = (x + dx) * PIXEL_SIZE
-			y = (y + dy) * PIXEL_SIZE
+			x = int(math.floor(x * PIXEL_SIZE))
+			y = int(math.floor(y * PIXEL_SIZE))
 			if start:
 				pen.moveTo(x, y)
 				start = False
@@ -132,5 +303,90 @@ def drawImage(image, pen, *, dx=0, dy=0):
 				pen.lineTo(x, y)
 		pen.closePath()
 
-generateFont()
+BOLD_THIN_DISTS = {
+	"Black": 0.3,
+	"Bold": 0.2,
+	"Demi": 0.1,
+	"Light": -0.1,
+	"Extra-Light": -0.3,
+}
+ITALIC_RATIO = math.tan(math.radians(15))
+
+def boldify(p, boldness):
+	l = len(p)
+	for i in range(l):
+		x, y = p[i]
+		dx, dy = 0, 0
+		px, py = p[i - 1]
+		if px < x:
+			dy += boldness
+		elif px > x:
+			dy -= boldness
+		elif py < y:
+			dx -= boldness
+		else:
+			dx += boldness
+		px, py = p[(i + 1) % l]
+		if px < x:
+			dy -= boldness
+		elif px > x:
+			dy += boldness
+		elif py < y:
+			dx += boldness
+		else:
+			dx -= boldness
+		yield (dx + x, dy + y)
+
+def createChar(
+	fontList,
+	code,
+	name,
+	image=None,
+	*,
+	width=None,
+	dx=0,
+	dy=0,
+	glyphclass=None,
+):
+	if image is not None:
+		poly = [[(x + dx, y + dy) for x, y in p]
+				for p in generatePolygons(image)]
+
+	poly_b = None
+	poly_t = None
+
+	for font in fontList:
+		if font is None:
+			continue
+		char = font.createChar(code, name)
+		#char.manualHints = True
+		if glyphclass is not None:
+			char.glyphclass = glyphclass
+		if image is None:
+			char.width = width if width is not None else PIXEL_SIZE * 6
+			continue
+
+		p = poly
+		try:
+			dist = BOLD_THIN_DISTS[font.weight]
+		except KeyError:
+			dist = 0
+
+		if dist > 0:
+			if poly_b is None:
+				poly_b = [[(x + dx, y + dy) for x, y in p] for p in generatePolygons(image, join_polygons=False)]
+			p = (boldify(p, dist) for p in poly_b)
+		elif dist < 0:
+			if poly_t is None:
+				poly_t = [[(x + dx, y + dy) for x, y in p] for p in generatePolygons(image, join_polygons=False, exclude_corners=True)]
+			p = (boldify(p, dist) for p in poly_t)
+
+		if font.macstyle & 2:
+			p = (((x + y * ITALIC_RATIO, y) for x, y in p) for p in p)
+
+		drawPolygon(p, char.glyphPen())
+		char.width = width if width is not None else PIXEL_SIZE * 6
+
+args = parseArgs()
+generateFont(**vars(args))
 generateExamples(characters, ligatures, charactersByCodepoint)
diff --git a/src/polygonizer.py b/src/polygonizer.py
index e102414..ead3334 100644
--- a/src/polygonizer.py
+++ b/src/polygonizer.py
@@ -94,7 +94,7 @@ def __getitem__(self, key):
 
     def __setitem__(self, key, value):
         ''' Sets a pixel at (x, y).
-        
+
         Do nothing if out of bounds.
         '''
         x, y = key
@@ -187,10 +187,36 @@ def __or__(self, other):
 
         return ret
 
+    def crop(self, min_x, max_x, min_y, max_y):
+        if max_x < min_x or max_y < min_y:
+            raise ValueError('Invalid bounds')
+
+        min_x = max(min_x, self._x)
+        max_x = min(max_x, self.x_end)
+        min_y = max(min_y, self._y)
+        max_y = min(max_y, self.y_end)
+        if max_x <= min_x or max_y <= min_y:
+            return PixelImage()
+
+        data = bytearray((max_x - min_x) * (max_y - min_y))
+        ix = 0
+        for j in range(min_y, max_y):
+            for i in range(min_x, max_x):
+                data[ix] = self[i, j]
+                ix += 1
+
+        return PixelImage(
+            x=min_x,
+            y=min_y,
+            width=max_x - min_x,
+            height=max_y - min_y,
+            data=data,
+        )
+
 
-def generatePolygons(image):
+def generatePolygons(image, **kw):
     for segment, start_pos in segmentize(image):
-        yield from polygonizeSegment(segment, start_pos)
+        yield from polygonizeSegment(segment, start_pos, **kw)
 
 
 def segmentize(image):
@@ -322,25 +348,20 @@ def reverse(self):
         return ret
 
 
-def polygonizeSegment(image, start_pos):
-    x, y = start_pos
-
-    # Make sure position is top left
-    assert image[x, y]
-    assert not (image[x - 1, y] or image[x - 1, y - 1] or image[x, y - 1]
-                or image[x + 1, y - 1])
+class Turtle:
+    __slots__ = ['img', 'x', 'y', 'dir']
 
-    dir = CellFlag.RIGHT
-
-    def doMove():
-        nonlocal x, y, dir
+    def __init__(self, img, x, y, dir):
+        self.img, self.x, self.y, self.dir = img, x, y, dir
 
+    def _move(self):
         # Set wall
-        d_ccw, d_cw, d_rev = dir.ccw(), dir.cw(), dir.reverse()
-        image[x, y] |= d_ccw
+        d_ccw, d_cw, d_rev = self.dir.ccw(), self.dir.cw(), self.dir.reverse()
+        p = self.x, self.y
+        self.img[p] |= d_ccw
 
-        x_, y_ = d_ccw.move((x, y))
-        assert not image[x_, y_] & CellFlag.ACTIVE
+        p_ = d_ccw.move(p)
+        assert not self.img[p_] & CellFlag.ACTIVE
 
         # Build boundary wall from this point
         # For all diagrams, it is assumed movement direction is right
@@ -348,252 +369,398 @@ def doMove():
         # ? . #
         # ? X ?
         # ? ? ?
-        x_, y_ = (dir | d_ccw).move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = (self.dir | d_ccw).move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Top-right corner
-            ret = [(dir | d_ccw).corner((x, y))]
+            ret = [(self.dir | d_ccw).corner(p)]
 
             # ? . ^
             # ? X ?
             # ? ? ?
-            x, y = x_, y_
-            dir = d_ccw
+            (self.x, self.y), self.dir = p_, d_ccw
             return ret
 
         # ? . .
         # ? X #
         # ? ? ?
-        x_, y_ = dir.move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = self.dir.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # ? . .
             # ? X >
             # ? ? ?
-            x, y = x_, y_
+            self.x, self.y = p_
             return []  # No corner
 
         # ? . .
         # ? X .
         # ? ? #
-        x_, y_ = (dir | d_cw).move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = (self.dir | d_cw).move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Two corners: top-right and bottom-right
             ret = [
-                (dir | d_ccw).corner((x, y)),
-                (dir | d_cw).corner((x, y)),
+                (self.dir | d_ccw).corner(p),
+                (self.dir | d_cw).corner(p),
             ]
 
             # ? . .
             # ? X .
             # ? ? >
-            image[x, y] |= dir
-            x, y = x_, y_
+            self.img[p] |= self.dir
+            self.x, self.y = p_
             return ret
 
         # ? . .
         # ? X .
         # ? # .
-        x_, y_ = d_cw.move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = d_cw.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Top-right corner
-            ret = [(dir | d_ccw).corner((x, y))]
+            ret = [(self.dir | d_ccw).corner(p)]
 
             # ? . .
             # ? X .
             # ? v .
-            image[x, y] |= dir
-            x, y = x_, y_
-            dir = d_cw
+            self.img[p] |= self.dir
+            (self.x, self.y), self.dir = p_, d_cw
             return ret
 
         # ? . .
         # ? X .
         # # . .
-        x_, y_ = (d_rev | d_cw).move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = (d_rev | d_cw).move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Three corners: top-right, bottom-right, and bottom-left
             ret = [
-                (dir | d_ccw).corner((x, y)),
-                (dir | d_cw).corner((x, y)),
-                (d_cw | d_rev).corner((x, y)),
+                (self.dir | d_ccw).corner(p),
+                (self.dir | d_cw).corner(p),
+                (d_cw | d_rev).corner(p),
             ]
 
             # ? . .
             # ? X .
             # v . .
-            image[x, y] |= dir | d_cw
-            x, y = x_, y_
-            dir = d_cw
+            self.img[p] |= self.dir | d_cw
+            (self.x, self.y), self.dir = p_, d_cw
             return ret
 
         # ? . .
         # # X .
         # . . .
-        x_, y_ = d_rev.move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = d_rev.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Two corners: top-right and bottom-right
             ret = [
-                (dir | d_ccw).corner((x, y)),
-                (dir | d_cw).corner((x, y)),
+                (self.dir | d_ccw).corner(p),
+                (self.dir | d_cw).corner(p),
             ]
 
             # ? . .
             # < X .
             # . . .
-            image[x, y] |= dir | d_cw
-            x, y = x_, y_
-            dir = d_rev
+            self.img[p] |= self.dir | d_cw
+            (self.x, self.y), self.dir = p_, d_rev
             return ret
 
         # # . .
         # . X .
         # . . .
-        x_, y_ = (d_rev | d_ccw).move((x, y))
-        if image[x_, y_] & CellFlag.ACTIVE:
+        p_ = (d_rev | d_ccw).move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
             # Four corners: top-right, bottom-right, bottom-left, and top-left
             ret = [
-                (dir | d_ccw).corner((x, y)),
-                (dir | d_cw).corner((x, y)),
-                (d_cw | d_rev).corner((x, y)),
-                (d_ccw | d_rev).corner((x, y)),
+                (self.dir | d_ccw).corner(p),
+                (self.dir | d_cw).corner(p),
+                (d_cw | d_rev).corner(p),
+                (d_ccw | d_rev).corner(p),
             ]
 
             # < . .
             # . X .
             # . . .
-            image[x, y] |= dir | d_cw | d_rev
-            x, y = x_, y_
-            dir = d_rev
+            self.img[p] |= self.dir | d_cw | d_rev
+            (self.x, self.y), self.dir = p_, d_rev
             return ret
 
         # . . .
         # . X .
         # . . .
-        image[x, y] |= dir | d_cw | d_rev
+        self.img[p] |= self.dir | d_cw | d_rev
         # Four corners: top-right, bottom-right, bottom-left, and top-left
         return [
-            (dir | d_ccw).corner((x, y)),
-            (dir | d_cw).corner((x, y)),
-            (d_cw | d_rev).corner((x, y)),
-            (d_ccw | d_rev).corner((x, y)),
+            (self.dir | d_ccw).corner(p),
+            (self.dir | d_cw).corner(p),
+            (d_cw | d_rev).corner(p),
+            (d_ccw | d_rev).corner(p),
         ]
 
-    def find(l, x):
-        try:
-            return l.index(x)
-        except ValueError:
-            return None
-
-    # Generate outer polygon
-    outer_poly = []
-    line = doMove()
-    i = find(line, start_pos)
-    while i is None:
-        outer_poly += line
-        line = doMove()
-        i = find(line, start_pos)
-    outer_poly += line[:i + 1]
-
-    assert checkPoly(outer_poly)
-
-    points_ = dict(
-        zip(
-            reversed(outer_poly),
-            range(len(outer_poly) - 1, -1, -1),
-        ))
-    points = defaultdict(set)
-    for p in outer_poly:
-        points[p].add(0)
-
-    poly = [(outer_poly, points_)]
-
-    # Calculate bounding box
-    x_min, y_min, x_max, y_max = x, y, x, y
-    for x, y in outer_poly:
-        if x_min > x:
-            x_min = x
-        if x_max < x:
-            x_max = x
-        if y_min > y:
-            y_min = y
-        if y_max < y:
-            y_max = y
-
-    # Generate inner polygon
-    for y in range(y_min, y_max):
-        for x in range(x_min, x_max):
+    def _move_4way(self):
+        # Set wall
+        d_ccw, d_cw, d_rev = self.dir.ccw(), self.dir.cw(), self.dir.reverse()
+        p = self.x, self.y
+        self.img[p] |= d_ccw
+
+        p_ = d_ccw.move(p)
+        assert not self.img[p_] & CellFlag.ACTIVE
+
+        # Build boundary wall from this point
+        # For all diagrams, it is assumed movement direction is right
+
+        # ? . ?
+        # ? X #
+        # ? ? ?
+        p_ = self.dir.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
+
+            # ? . #
+            # ? X #
+            # ? ? ?
+            p__ = d_ccw.move(p_)
+            if self.img[p__] & CellFlag.ACTIVE:
+                # Top-right corner
+                ret = [(self.dir | d_ccw).corner(p)]
+
+                # ? . ^
+                # ? X #
+                # ? ? ?
+                (self.x, self.y), self.dir = p__, d_ccw
+                return ret
+
+            # ? . .
+            # ? X #
+            # ? ? ?
+            else:
+                # ? . .
+                # ? X >
+                # ? ? ?
+                self.x, self.y = p_
+                return []  # No corner
+
+        # ? . ?
+        # ? X .
+        # ? # ?
+        p_ = d_cw.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
+            self.img[p] |= self.dir
+
+            # ? . ?
+            # ? X .
+            # ? # #
+            p__ = self.dir.move(p_)
+            if self.img[p__] & CellFlag.ACTIVE:
+                # Two corners: top-right and bottom-right
+                ret = [
+                    (self.dir | d_ccw).corner(p),
+                    (self.dir | d_cw).corner(p),
+                ]
+
+                # ? . ?
+                # ? X .
+                # ? # >
+                self.x, self.y = p__
+                return ret
+
+            # ? . ?
+            # ? X .
+            # ? # .
+            else:
+                # Top-right corner
+                ret = [(self.dir | d_ccw).corner(p)]
+
+                # ? . ?
+                # ? X .
+                # ? v .
+                (self.x, self.y), self.dir = p_, d_cw
+                return ret
+
+        # ? . ?
+        # # X .
+        # ? . ?
+        p_ = d_rev.move(p)
+        if self.img[p_] & CellFlag.ACTIVE:
+            self.img[p] |= self.dir | d_cw
+
+            # ? . ?
+            # # X .
+            # # . ?
+            p__ = d_cw.move(p_)
+            if self.img[p__] & CellFlag.ACTIVE:
+                # Three corners: top-right, bottom-right, and bottom-left
+                ret = [
+                    (self.dir | d_ccw).corner(p),
+                    (self.dir | d_cw).corner(p),
+                    (d_cw | d_rev).corner(p),
+                ]
+
+                # ? . ?
+                # # X .
+                # v . .
+                (self.x, self.y), self.dir = p__, d_cw
+                return ret
+
+            # ? . ?
+            # # X .
+            # . . ?
+            else:
+                # Two corners: top-right and bottom-right
+                ret = [
+                    (self.dir | d_ccw).corner(p),
+                    (self.dir | d_cw).corner(p),
+                ]
+
+                # ? . ?
+                # < X .
+                # . . ?
+                (self.x, self.y), self.dir = p_, d_rev
+                return ret
+
+        # ? . ?
+        # . X .
+        # ? . ?
+        self.img[p] |= self.dir | d_cw | d_rev
+        # Four corners: top-right, bottom-right, bottom-left, and top-left
+        return [
+            (self.dir | d_ccw).corner(p),
+            (self.dir | d_cw).corner(p),
+            (d_cw | d_rev).corner(p),
+            (d_ccw | d_rev).corner(p),
+        ]
+
+    def trace(self, stop_pos, exclude_corners=False):
+        poly = []
+        while True:
+            j = len(poly)
+            poly += self._move_4way() if exclude_corners else self._move()
+            try:
+                i = poly.index(stop_pos, j)
+            except ValueError:
+                continue
+
+            return poly[:i + 1]
+
+
+def polygonize(image, exclude_corners=False):
+    image = PixelImage(image)
+
+    ret = []
+    turtle = Turtle(image, 0, 0, CellFlag.LEFT)
+    for y in range(image.y, image.y_end):
+        for x in range(image.x, image.x_end):
             v = image[x, y]
             if not v & CellFlag.ACTIVE:
                 continue
 
-            if not (image[x, y + 1] & CellFlag.ACTIVE or v & CellFlag.DOWN):
-                dir = CellFlag.LEFT
+            if not (v & CellFlag.UP or image[x, y - 1] & CellFlag.ACTIVE):
+                turtle.dir, stop_pos = CellFlag.RIGHT, (x, y)
+            elif not (v & CellFlag.RIGHT or image[x + 1, y] & CellFlag.ACTIVE):
+                turtle.dir, stop_pos = CellFlag.DOWN, (x + 1, y)
             else:
                 continue
+            turtle.x, turtle.y = x, y
 
-            # Store iterator value
-            p = x, y
+            ret.append(turtle.trace(stop_pos, exclude_corners)[::-1])
+            assert checkPoly(ret[-1])
 
-            inner_poly = []
-            line = doMove()
-            i = None
-            while i is None:
-                inner_poly += line
-                line = doMove()
-                i = find(line, inner_poly[0])
-            inner_poly += line[:i]
+    return ret
 
-            assert checkPoly(inner_poly)
 
-            j = len(poly)
-            poly.append((
-                inner_poly,
-                dict(
-                    zip(
-                        reversed(inner_poly),
-                        range(len(inner_poly) - 1, -1, -1),
-                    )),
-            ))
-            for i in inner_poly:
-                points[i].add(j)
-
-            # Restore iterator value
-            x, y = p
+def joinPolygons(polygons):
+    def first_equals(i, j, *, key=lambda x: x):
+        i, j = enumerate(map(key, i)), enumerate(map(key, j))
+        try:
+            (ai, av), (bi, bv) = next(i), next(j)
+            while av!= bv:
+                if av < bv:
+                    ai, av = next(i)
+                else:
+                    bi, bv = next(j)
+            return ai, bi
+        except StopIteration:
+            pass
+
+    def merge(i, j):
+        r = []
+        i, j = iter(i), iter(j)
+        a, b = next(i, None), next(j, None)
+        while a is not None and b is not None:
+            if a[1] == b[1]:
+                r.append((min(a[0], b[0]), a[1]))
+                a, b = next(i, None), next(j, None)
+            elif a[1] < b[1]:
+                r.append(a)
+                a = next(i, None)
+            else:
+                r.append(b)
+                b = next(j, None)
 
-    # Try to join polygons
-    for i in range(len(poly) - 1, -1, -1):
-        inner_poly, points_ = poly[i]
+        if a is not None:
+            r.extend(i)
+        elif b is not None:
+            r.extend(j)
 
-        for v in points.values():
-            if len(v) > 1 and i in v:
-                j = min(v)
-                break
-        else:
-            continue
+        return r
 
-        outer_poly, points__ = poly[j]
+    kf = lambda v: v[1]
 
-        for i_, p in enumerate(inner_poly):
-            j_ = points__.get(p)
-            if j_ is not None:
-                break
-        else:
-            raise RuntimeError(
-                f'Should not happened {inner_poly} {outer_poly}')
+    def f(p):
+        l = []
+        x = None
+        for i, v in sorted(enumerate(p), key=kf):
+            if x != v:
+                x = v
+                l.append((i, v))
+        return p, l
+
+    def checkPoints(p, l):
+        if not checkPoly(p):
+            return False
+        for i in range(len(l)):
+            j, v = l[i]
+            if j >= len(p) or p[j] != v:
+                print(f'{p}\n{l} Error at {i} ({j}, {v}) (got {None if j >= len(p) else p[j]})')
+                return False
+            if i < 1:
+                continue
+            _, t = l[i - 1]
+            if t == v:
+                print(f'{p}\n{l} Error at {i} ({j}, {v})')
+                return False
+        return True
+
+    points = [f(i) for i in polygons]
+    for i in range(len(points) - 1, 0, -1):
+        p, l = points[i]
+        for j in range(i):
+            p_, l_ = points[j]
+            t = first_equals(l, l_, key=kf)
+            if t is None:
+                continue
+
+            a, b = t
+            a, _ = l[a]
+            b, _ = l_[b]
+            p = [*p[:a], *p_[b:], *p_[:b], *p[a:]]
+
+            t = len(p_)
+            s = t - b + a
+            r = a - b
+            l = merge(
+                ((i + t if i >= a else i, v) for i, v in l),
+                ((i + r if i >= b else i + s, v) for i, v in l_),
+            )
+
+            assert checkPoints(p, l)
+            points[j] = p, l
+            del points[i]
+            break
 
-        outer_poly[j_:j_] = [*inner_poly[i_:], *inner_poly[:i_]]
-        points__.update(
-            zip(
-                reversed(outer_poly),
-                range(len(outer_poly) - 1, -1, -1),
-            ))
+    return [p[0] for p in points]
 
-        del poly[i]
-        for v in points.values():
-            v.discard(i)
 
-    # Emit polygons
-    for i, _ in poly:
-        yield i
+def generatePolygons(image, *, join_polygons=True, exclude_corners=False, **kw):
+    ret = polygonize(image, exclude_corners)
+    if join_polygons:
+        ret = joinPolygons(ret)
+    return ret
 
 
 def checkPoly(poly):
@@ -651,7 +818,7 @@ def testChar(name, pixels):
 
     print(f'Character: {name}\n{image}\n\n')
 
-    for poly in generatePolygons(image):
+    for poly in generatePolygons(image, join_polygons=False, exclude_corners=True):
         print('Polygon:\n  ' + '\n  '.join(f'{x}, {y}'
                                            for x, y in poly) + '\n\n')