DEV Community: ramya Thirunavukkarasu

How I Turned My Handwriting Into a Font Using Python

ramya Thirunavukkarasu — Mon, 16 Mar 2026 03:21:19 +0000

we’ll build a simple system using Python that converts your handwritten characters into a TrueType font (.ttf).
Step 1 – Install the Required Library
First, we need a Python library called Pillow. It helps us create and edit images.
Open your terminal or command prompt and run:
pip install pillow
Once it installs, you're ready to move to the next step.
Step 2 – Create a Template for Handwriting
Instead of manually drawing boxes for every letter, we can let Python generate a template automatically.
Create a new file called:
create_template.py
Add the following code:
from PIL import Image, ImageDraw, ImageFont
font_size = 80
image_width = 2600
image_height = 1200
font_path = "arial.ttf"
output_image_path = "template_image.png"
characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
template_image = Image.new("RGB", (image_width, image_height), "white")
draw = ImageDraw.Draw(template_image)
font = ImageFont.truetype(font_path, font_size)
x = 50
y = 100
for char in characters:
draw.text((x, y-60), char, fill="black", font=font)
draw.rectangle([x, y, x+80, y+80], outline="black")
x += 120
if x > 2400:
x = 50
y += 150
template_image.save(output_image_path)
print("Template created:", output_image_path)
Now run the script:
python create_template.py
After running it, a new image will appear in your folder:
template_image.png
This image contains boxes for every letter.
Step 3 – Fill the Template With Your Handwriting
Now comes the fun part.
Open the image:
template_image.png
You can use any drawing tool like:
Paint
Photoshop
Inkscape
Draw your handwriting inside each box.
For example:
[A] [B] [C]
[D] [E] [F]
Once you're done, save the file as:
filled_template_image.png
Step 4 – Extract Each Character
Now we need to cut each letter into separate images.
Create a new Python file called:
extract_characters.py
Add this code:
from PIL import Image
import os
image = Image.open("filled_template_image.png")
characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
os.makedirs("character_images", exist_ok=True)
x = 50
y = 100
for char in characters:
crop = image.crop((x, y, x+80, y+80))
crop.save(f"character_images/{char}.png")
x += 120
if x > 2400:
x = 50
y += 150
print("Characters extracted")
Run it:
python extract_characters.py
A new folder will appear:
character_images
Inside it, you'll see files like:
A.png
B.png
C.png
Each letter is now stored as its own image.
Step 5 – Convert the Images Into a Font
Now we turn those images into a real font.
Create another file called:
create_handwriting_font.py
Add the script that converts the character images into a .ttf font.
This script uses FontForge to map each character image to its Unicode value and generate the font file.
import os
import fontforge
from PIL import Image, ImageDraw, ImageFont
font_size = 80
image_width = 2600
image_height = 1200
font_path = "arial.ttf"
output_image_path = "template_image.png"
filled_template_image_path = "filled_template_image.png"
output_directory = "character_images"
output_font_path = "handwritten_font.ttf"
english_characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
def create_template_image():
template_image = Image.new("RGB", (image_width, image_height), "white")
draw = ImageDraw.Draw(template_image)
font = ImageFont.truetype(font_path, font_size)
x = 50
y = 50
character_positions = {}
for char in english_characters:
draw.text((x, y), char, fill="black", font=font)
box = (x, y+80, x+font_size, y+80+font_size)
draw.rectangle(box, outline="black")
character_positions[char] = box
x += font_size * 2

    if x > image_width - font_size:
        x = 50
        y += font_size * 2  template_image.save(output_image_path)
print("Template created")
return character_positions

def crop_character_images(character_positions):
img = Image.open(filled_template_image_path)
os.makedirs(output_directory, exist_ok=True)
for char, pos in character_positions.items():
crop = img.crop(pos) crop.save(os.path.join(output_directory, f"{char}.png"))
print("Characters cropped")
def create_font(character_positions):
font = fontforge.font()
font.familyname = "HandwrittenEnglish"
font.fontname = "HandwrittenEnglish"
for char in english_characters:
unicode_val = ord(char)
glyph = font.createChar(unicode_val)
image_path = os.path.join(output_directory, f"{char}.png")
if os.path.exists(image_path): glyph.importOutlines(image_path)
glyph.addExtrema()
glyph.simplify() glyph.correctDirection()
font.generate(output_font_path)
print("Font generated:", output_font_path)
def main():
positions = create_template_image()
print("Fill template and save as filled_template_image.png")
input("Press Enter after filling handwriting...") crop_character_images(positions)
create_font(positions)
if name == "main":
main()
After running the script, Python will generate:
handwritten_font.ttf
Step 6 – Install Your Font
Once the font file is created, install it on your system.
Then open any program like:
Microsoft Word
Notion
Google Docs
Final thoughts
However,in my case the font installs successfully, but it does not appear in Microsoft Word yet. This means there is still something that needs to be fixed in the font generation process.
So in my next blog, I will explain:
Why the font is not appearing in Word
What changes are needed in the code
How to properly generate a working font
Stay tuned for the next part where we will fix this issue and make the handwriting font work properly.

Convert Images to SVG in Python Using vtracer 🚀

ramya Thirunavukkarasu — Thu, 12 Mar 2026 18:30:56 +0000

Recently I found a Python library called VTracer that can convert images to SVG automatically.
SVG files use vector paths, which means they can scale to any size without losing quality. That’s why logos, icons, and illustrations are often stored as SVG files.
But converting raster images into vectors usually requires design software.
The challenge is converting pixel images into vector shapes automatically.
What is VTracer?
VTracer is a tool that helps turn normal images into vector graphics.
In simple words, it takes images like PNG or JPG (which are made of pixels) and converts them into SVG files (which are made of vector shapes). SVG images can be resized to any size without losing quality.
Installing VTracer
Just install it with pip:
pip install vtracer
Converting an Image to SVG:
Sample:
import vtracer
input_path = "input.jpg"
output_path = "output.svg"
vtracer.convert_image_to_svg_py(input_path, output_path)
Final Thoughts
Not every image will convert perfectly. Complex photos probably won’t turn into clean vectors.
But for logos, icons, and simple graphics, this works really well.
And the best part is that it takes only a few lines of Python.

Exploring FontForge Libraries: UFO, XML and Unicode

ramya Thirunavukkarasu — Tue, 10 Mar 2026 18:22:31 +0000

FontForge supports different font technologies that help designers create, store, and share fonts easily. Some important ones are UFO, XMLand Unicode. Each of them helps FontForge handle fonts in different ways.
UFO (Unified Font Object)
UFO is a font format mainly used by font designers while developing a font.
Instead of storing everything in one big file, UFO stores font data in a folder with multiple readable files. These files contain information about glyph shapes, spacing, kerning, and other font details.
Because of this structure, UFO is very useful for:
Editing fonts easily
Working with other font tools
Tracking changes using version control systems like Git
FontForge can open, edit, and export UFO files, making it easier for designers to manage font projects.
XML
XML stands for Extensible Markup Language. It is a format used to store data in a structured and readable way.
In FontForge, XML is used to store certain types of font information and metadata.
This helps because:
The data is organized and easy to read
Programs can easily process the information
Font settings and structures can be stored clearly
FontForge uses XML libraries to read and write this structured data.
Unicode
Unicode is a universal system that assigns a unique number to every character used in languages around the world.
For example:
English letters
Tamil characters
Arabic scripts
Symbols and emojis
FontForge uses Unicode to connect each glyph in a font to a specific character. This ensures that when someone types a letter, the correct glyph from the font is displayed.
Unicode support allows FontForge to create fonts that work across different languages and platforms.
Pillow vs VTracer – What’s the Difference?
When working with images in Python, two libraries you might encounter are Pillow and VTracer. Although both deal with images, they serve very different purposes.
Pillow:
Pillow is a popular Python library used for general image processing. It is actually the modern version of the Python Imaging Library (PIL).
What Pillow Does
Pillow works with raster images (pixel-based images). It allows you to manipulate images by editing pixels.
Common Features
With Pillow you can:
Open and save images
Resize images
Crop images
Rotate images
Apply filters
Convert image formats (PNG, JPG, etc.)
Example
from PIL import Image
img = Image.open("photo.jpg")
img.resize((300,300))
img.save("resized.jpg")
When to Use Pillow
Use Pillow when you need to:
Edit photos
Resize or crop images
Apply filters
Convert image formats
Pillow is mainly used in image processing and computer vision projects.
VTracer:
VTracer is a library used for image vectorization. It converts raster images into vector graphics.
What VTracer Does
VTracer analyzes shapes in an image and converts them into SVG vector paths.
Key Features
Converts PNG/JPG to SVG
Detects shapes and outlines
Supports colored images
Produces scalable graphics
Example
import vtracer
vtracer.convert_image_to_svg_py("image.png", "output.svg")
When to Use VTracer
Use VTracer when you need to:
Convert images into vector graphics
Create scalable graphics
Vectorize logos or icons
Convert drawings into SVG

Inside the Noto Tamil Font Repository: How Tamil Fonts Are Built

ramya Thirunavukkarasu — Wed, 04 Mar 2026 16:16:58 +0000

When Google launched the Noto project, the mission was ambitious but simple:
No more tofu boxes (□) showing up when text fails to render.
The goal was to support every script in Unicode — properly and consistently — across platforms.
One part of that effort is Noto Sans Tamil and its serif companion Noto Serif Tamil, developed openly in this repository:
🔗 https://github.com/notofonts/tamil⁠�
I explored this repository with one question in mind:
How does a Tamil font actually get built?
What I found was a mix of design, engineering, automation, and strict quality control.
What Is Noto Tamil?
it’s “just a font.”
But Tamil is not a simple script.
It includes:
Independent vowels
Consonants that combine with vowel signs
Context-based glyph substitutions
Combining marks and ligatures
Designing a Tamil font isn’t just drawing characters.
It’s making sure characters behave correctly when combined.
That behavior is controlled by Unicode standards and OpenType rules.
In other words:
A Tamil font is as much engineering as it is design.
Opening the Repository
When you open the repository, you don’t see pretty letter previews first.
You see structure:
sources/
scripts/
qa/
documentation/
Makefile
requirements.txt
fontbakery.yml
The Project:
sources/
This is where the real work lives.
Inside this folder are:
Glyph outlines
OpenType feature definitions
Character mappings
This is where designers define how letters look.
It’s also where engineers define how letters interact.
The shape of a character is only half the story.
The logic behind how it behaves is just as important.
Automation: scripts/
Instead of manually exporting font files, the repository uses Python scripts to compile everything.
That means:
Repeatable builds
Fewer human errors
Structured releases
Fonts today are built more like software releases than art files.
Quality Control: qa/
Before any font is considered complete, it must pass automated checks.
These tests verify:
Unicode correctness
Proper naming standards
Rendering consistency
Licensing information
Nothing gets merged casually.
Everything is validated.
How the Build Process Works
The repository uses a Makefile-based workflow.
To build the font:
make build
To run tests:
make test
To generate visual proof files:
make proof
Behind these simple commands:
Python tools compile glyphs
OpenType features are processed
Font files (.ttf) are generated
QA tests run automatically
It’s a clean, professional pipeline.
Continuous Integration
Whenever someone pushes changes:
Fonts are rebuilt automatically
Tests run
Proof files are generated
This ensures broken fonts never get merged.
It’s production-level engineering for typography.
Understanding Tamil Font Logic
Tamil requires:
Correct Unicode mapping
GSUB (Glyph Substitution)
GPOS (Glyph Positioning)
Precise mark attachment
Ligature handling
For example:
A consonant plus a vowel sign must render correctly together.
If anchor points are slightly misaligned, the text looks broken.
These positioning rules are defined in OpenType feature files.
It’s invisible work — but absolutely essential.
From Design to Final Font
The pipeline looks like this:
Glyph Design → Feature Programming → Build Scripts → TTF Output → QA Validation
The final .ttf file you download is the result of:
Vector outline definitions
Layout logic
Metadata generation
Automation scripts
Quality validation.
⚠️ Drawbacks
While the Noto Tamil repository is well-structured and professional, it has a few challenges:
Steep learning curve – Requires knowledge of Unicode, OpenType (GSUB/GPOS), and build systems.
Strict build process – Small mistakes can break the build or fail QA checks.
Slow debugging cycle – Every change requires rebuilding and reinstalling the font.
Complex script handling – Tamil combining marks and substitutions increase technical difficulty.
Limited creative flexibility – Focused on consistency and
neutrality.
Final thoughts:
After exploring the Noto Tamil repository, I realized how much effort goes into something we usually take for granted. A font isn’t just shapes on a screen — it’s careful design, technical rules, repeated testing, and a lot of patience.
At the same time, it’s not easy to work with. Understanding Unicode, OpenType features, and the build process can be difficult, especially for beginners. Even small changes can take time to test and verify. But that difficulty is part of what keeps the font stable and reliable.

How to Create a Tamil Unicode Font Using FontForge

ramya Thirunavukkarasu — Tue, 24 Feb 2026 17:52:39 +0000

Introduction
Tamil font creation has become easier because of Unicode standards and open-source software. One of the most powerful tools for font design is FontForge. Using FontForge, we can draw Tamil letters, assign Unicode values, and generate font files like .ttf. we will create a simple Tamil glyph and export it as a font.
Step 1 – Install FontForge
Download FontForge:
https://fontforge.org
FontForge is available for:
Windows
Linux
macOS
After installing, open the software.
Step 2 – Open FontForge and Understand Glyph Grid
When FontForge opens, you will see a glyph grid (many small boxes).
Each box represents a Unicode character slot.
Example:
U+0B95 → க
Each Tamil letter must be placed in its correct Unicode position.
Step 3 – Set Unicode Encoding
To work with Tamil Unicode:
Menu:
Encoding → Reencode → Unicode Full
Tamil Unicode block range:
U+0B80 – U+0BFF
Now FontForge is ready for Tamil font creation.
Step 4 – Find a Tamil Letter Slot
Press:
Ctrl + F
Search Unicode:
0B95
This opens the slot for the Tamil letter:
க
Step 5 – Import Glyph from Inkscape
If you already created the letter in SVG format using vector software:
Menu:
File → Import
Select file:
uni0B95.svg
Now the glyph outline appears inside FontForge.
Step 6 – Edit Glyph Shape
Double-click the glyph box to open the editor window.
You can:
*Move nodes
*Smooth curves
*Resize shapes
*Adjust alignment
This step improves the quality of the font outline.
Step 7 – Adjust Spacing (Metrics)
Correct spacing is important for readability.
Open:
Window → New Metrics Window
Adjust:
Left spacing
Right spacing
Tamil letters should not touch each other while typing.
Step 8 – Generate Font File
After finishing glyph design:
Menu:
File → Generate Fonts
Choose format:
TrueType (.ttf)
Now your Tamil font file is ready.
Install the .ttf file and test typing.

Open Source Tamil Fonts: Noto Sans Tamil
Noto Sans Tamil is an open-source Unicode Tamil font developed by Google as part of the Noto Fonts project.
It supports all Tamil Unicode characters (U+0B80–U+0BFF) and works on mobile, web, and desktop applications.
The font is released under the SIL Open Font License, so anyone can:
*Download
*Use
*Modify
*Share the font freely
The source files are available on GitHub, which helps designers learn Tamil font development.
Noto Sans Tamil is widely used for:
Tamil typing
Graphic design
Web fonts
Unicode Tamil projects
This font is a good starting point for beginners learning Tamil typography and open-source font creation.

How to Convert Vector Letters into OTF (OpenType Font)

ramya Thirunavukkarasu — Wed, 11 Feb 2026 15:46:33 +0000

What Is OTF?
OTF (OpenType Font)
Supports advanced typography
Works on Windows, macOS, Linux
Is commonly used in design software (Photoshop, Illustrator, Word)
OTF fonts store:
Vector outlines of letters
Spacing information
Font metadata (name, style, author)
1.Create Vector Letters Correctly
Before FontForge, your vectors must be font-ready.
Rules for Vector Letters:
Use SVG or EPS
One letter per file
Paths must be:
Clean (no strokes, only fills)
No background rectangles
2.Create a New Font in FontForge
Open FontForge
Click:
File → New
What you see now:
A grid of empty boxes
Each box = one character (glyph)
For example:
Slot “A” → Capital A
Slot “a” → Small a
This grid is how FontForge maps vector shapes → keyboard characters.
3.Import Vector into a Glyph Slot
Double-click on a letter slot (example: A)
Go to:
File → Import
Select your SVG/EPS file
Now your vector appears inside the glyph editor.
4.Align and Scale the Letter
Inside the glyph window you’ll see lines:

Baseline → where letters sit
Ascender → top limit
Descender → bottom limit
What You Must Do:
Scale the letter to fit naturally
Place it correctly on the baseline
Do NOT touch the top too much
Why means:
Incorrect alignment causes:
Letters floating
Uneven text
Bad line spacing
5.Generate OTF File
Once all letters are imported:
Go to:
File → Generate Fonts
Choose format:
OpenType (CFF)
Name your font
Click Generate

**How to Convert Vector Letters into WOFF (Web Open Font Format)
What Is WOFF?
WOFF (Web Open Font Format) is:
A compressed font format
Designed specifically for websites
Supported by all modern browsers:
Browsers cannot use SVG letters directly
They need WOFF or WOFF2
You do NOT convert SVG → WOFF directly
You convert:
Vector → Font (OTF/TTF) → WOFF
FontForge handles this internally.
1.Generate WOFF Using FontForge
If your font project is already
Go to:
File → Generate Fonts
Select:
Web Open Font Format (WOFF)
Click Generate

How to Turn Vector Letters Into a Font File

ramya Thirunavukkarasu — Tue, 10 Feb 2026 13:56:24 +0000

Vector letters into ttf(truetype font):
you can turn your vector letter designs into a working TrueType font using a free tool called FontForge.
Need:
Before you start, make sure you have:
Vector letter designs (made in Illustrator, Inkscape, or any vector software)
FontForge, a free and open-source font-making tool
FontForge is where everything comes together it’s used to place your letters and export the final font file.
Step-by-Step: Turning Letters Into a Font

Prepare Your Vector Letters First, design all your letters (A–Z, numbers, and symbols) as vectors. Make sure that: Your letters are vector shapes, not images Everything is aligned, and sized properly Each character is ready to copy on its own
Open FontForge Open FontForge and start a new font project. You’ll see a grid filled with empty boxes. Each box represents a letter, number, or symbol in your font.
Add Your Letters to FontForge For each character: Double-click the correct box (for example, the letter “A”) Paste your vector letter inside Adjust the size and position so it fits nicely You’ll repeat this step for every letter. It’s a manual process, but it gives you full control.
Set Up Your Font Details Before exporting your font: Give your font a name Check spacing and alignment Make sure no letters are overlapping or too small These small details make a big difference when typing.
Export Your Font Once all letters are added: Export the font as a .TTF file Install it on your computer Test it in your favorite design or text software

Font Creation Tools

ramya Thirunavukkarasu — Tue, 10 Feb 2026 13:28:16 +0000

Calligraphr:
An easy online tool that turns your handwritten text into a digital font.
Features:
*Converts handwritten text into digital fonts
*Supports popular font formats such as TTF and OTF
*Works directly in a web browser
Drawbacks:
*The free version supports only a limited number of characters
*Advanced features are available only through a paid subscription
*Offers limited control for complex or professional font design
FontForge:
A powerful desktop application used to create and edit professional fonts in detail.
Features:
*Free and open-source software
*Supports multiple font formats including TTF, OTF, SVG, and more
*Allows detailed editing of individual glyphs
*Available on Windows, macOS, and Linux
Drawbacks:
*Takes time to learn, especially for beginners
*The interface can feel confusing at first
*Needs patience and practice to use confidently
What is a Font?
A font is a digital representation of characters with a specific design style.
(letters, numbers, symbols, and punctuation)
Fonts define how text looks on a screen or when printed — including shape, thickness, spacing, and style.
What Type of File Is a Font Stored?
TTF (TrueType Font):
TTF is a widely supported font format developed by Apple and Microsoft. It is simple, reliable, and works well across all platforms. TTF fonts are commonly used for documents, basic designs, and handwritten fonts.
OTF (OpenType Font):
OTF is an advanced font format developed by Adobe and Microsoft. It supports more features such as decorative characters and better language support.
OTF is preferred for professional typography and advanced font design.
WOFF / WOFF2(Web Open Font Format):
WOFF and WOFF2 are used only on websites to make fonts load faster and look the same on all browsers.
How Is a Handwritten Font Created?
*Handwriting is written on paper or drawn digitally
*Each character is scanned or digitized
*Characters are converted into vector shapes
*Glyphs are assigned to keyboard characters
*Spacing and kerning are adjusted
*Font is exported as TTF or OTF
*Font is installed and tested

Learning Tech as an Intern

ramya Thirunavukkarasu — Mon, 09 Feb 2026 09:47:22 +0000

This blog is basically my tech notebook. I write about what I’m learning, what I’m working on. Most of it comes from my day-to-day work with code, projects I build. I’m learning in public and sharing the journey as it happens.