unifoundry.com

PostScript is a page description language: a program that tells a printer or renderer how to draw a page, including the shapes of every glyph. It matters for fonts because PostScript introduced outline-based font formats (notably Type 1) and a device-independent way to print text and graphics. It is not a character encoding, so it does not compete with Unicode — Unicode says which character a code point represents, while PostScript describes how to paint shapes on a page. The two meet when a Unicode-encoded document is rendered with PostScript-flavored fonts or sent to a PostScript printer.

What PostScript actually does

A PostScript file is executable: the interpreter reads commands such as "move to this coordinate, draw this curve, fill it." Text is drawn by selecting a font, mapping character codes to glyph names, and painting the glyph outlines.

Key consequences:

• Device independence. The same file can target different resolutions because coordinates are expressed in abstract units (typically 1/72 inch, a "point").
• Outlines, not bitmaps. Glyphs are stored as curves, so they scale cleanly. This is the core reason PostScript-era fonts look sharp at any size.
• Two layers. The language handles page layout and graphics; fonts supply the glyph programs. A missing or mismatched font breaks output even if the PostScript itself is valid.

Fonts in the PostScript workflow

The classic PostScript font format is Type 1, which stores glyphs as encrypted charstrings plus hinting information for small sizes. Later formats (Type 3, Type 42/TrueType wrapping, and OpenType with CFF outlines) also plug into PostScript printing pipelines.

For a concrete task: if you are preparing a document for a print shop that requires PostScript-compatible output, you need fonts whose outlines the RIP can interpret and whose embedding rights allow distribution. A font that renders fine on screen can still fail at the printer if it is bitmap-only or if embedding is restricted.

PostScript vs. Unicode fonts such as GNU Unifont

These solve different problems, and conflating them causes most confusion.

• Unicode is a character set and encoding standard. It assigns code points (for example, U+0041 for "A") and defines properties, but says nothing about drawing.
• GNU Unifont, per Unifoundry, is a bitmap font project providing a glyph for every printable code point in the Unicode Basic Multilingual Plane (BMP). The site notes that as of 20 June 2008 the font covered Unicode 5.1, the then-current version, culminating an effort begun by Roman Czyborra in 1998.
• PostScript is the drawing/printing layer. A bitmap font like Unifont is not a PostScript outline font; using it in a PostScript workflow generally means converting or wrapping it, and bitmap glyphs do not scale the way Type 1 outlines do.

So the practical distinction: Unicode answers "which character is this?"; PostScript answers "how do I draw and print it?" A font can be Unicode-complete and still be unsuitable for high-quality PostScript printing if it is bitmap-based.

When you need PostScript-compatible fonts

You need to convert or choose PostScript-compatible formats when:

• Sending files to a commercial printer or a PostScript RIP.
• Producing PDFs where fonts must embed as outlines or CFF.
• Using older publishing software that expects Type 1 fonts.

Common tool categories (verify current capabilities before relying on them):

• FontForge — converts between outline formats and can generate PostScript-flavored output; Unifoundry lists FontForge among its related resources.
• Ghostscript — interprets and renders PostScript/PDF.
• Font conversion utilities — for moving between TrueType, OpenType/CFF, and Type 1.

For bitmap fonts like Unifont, conversion to outlines is possible but changes the look: pixel edges become curves, and you must decide whether to keep the blocky aesthetic or smooth it.

Common failure points

• Missing glyphs. The document uses characters the font lacks; the renderer substitutes or drops them. Check coverage against your actual text, not just the script.
• Encoding mismatch. Codes map to wrong glyph names, producing garbled output. Confirm the font's encoding matches what the document assumes.
• Embedding restrictions. The license forbids embedding, or the workflow refuses the format. Unifoundry states its precompiled fonts are under GNU GPL v2 or later, with the exception that embedding a font in a document does not by itself bind that document to the GPL — read the specific license before distributing.
• Bitmap-in-outline pipeline. A bitmap font passed to an outline-only RIP fails or degrades. Convert deliberately and inspect the result.
• Font not found at print time. The printer lacks the font and no embedding was done; output falls back to a default.

Bottom line

Use PostScript thinking when your goal is printing and drawing: choose outline fonts, confirm embedding rights, and test the actual output path. Use Unicode thinking when your goal is character coverage: verify the font contains the code points your text needs. GNU Unifont is a strong answer to the coverage question for BMP scripts, but it is a bitmap font, so treat any PostScript use as a conversion decision rather than a drop-in.

Draw the character you need in Shapecatcher's drawing box, click Recognize, and the tool returns the most similar Unicode glyphs from its database of 11,817 characters. This works when you know what a symbol looks like but not its name or code point — and when the character falls within the tool's supported Unicode blocks. Chinese, Japanese, and Korean characters are not yet supported, so CJK searches will fail even if you draw them accurately.

Step-by-step: drawing and recognizing a character

1. Open shapecatcher.com. The drawing box ("drawbox") is the main workspace.
2. Draw your character by clicking and holding the left mouse button while moving the cursor. Add as many strokes as the character needs.
3. Use the Fill tool to fill in solid areas and Erase to remove mistakes. Clear wipes the canvas and the results.
4. Click Recognize to run recognition. The tool compares your sketch against its glyph database and lists the closest matches.
5. Pick the character you want from the results. If nothing matches, adjust the drawing and recognize again.

The expected result is a ranked list of visually similar Unicode characters. Recognition is shape-based, so stroke order and exact proportions matter less than overall form — but a rough or ambiguous sketch will produce poor matches.

What the database covers — and what it doesn't

The author notes that the recognition algorithms could handle many more characters and that the database may be extended in the future. The CJK gap exists because a suitable free CJK font hasn't been integrated yet — Google's Noto family (Apache 2.0 license) is named as a candidate, but inclusion is still a plan rather than a feature. If you need to confirm whether a specific block is covered, check the Unicode list linked from the site.

When your character isn't found

Work through these causes in order:

• The character isn't in the database. Only glyphs from free Unicode fonts are included, so some characters simply aren't there yet.
• It's a CJK character. These are excluded entirely for now.
• The drawing wasn't precise enough. The site's own advice is to draw as precisely as you can and try again. Recognition quality depends on how closely your sketch resembles the glyph.
• The recognition engine is offline. A "Bad Gateway" error means the engine can't be reached or is temporarily down. Wait and retry; the site invites email reports about outages.

If results are consistently disappointing for a character you believe should be supported, the author asks for an email describing the case.

Practical tips for better matches

• Draw the character large enough to fill a good portion of the box — small sketches lose distinguishing detail.
• Use Fill for characters with solid regions (blocks, filled circles) rather than scribbling over them.
• Keep the sketch clean: erase stray strokes before recognizing, since extra marks count as part of the shape.
• If the first result list is close but wrong, refine one feature at a time (a curve direction, a crossbar position) and recognize again.

Related tools and alternatives

Shapecatcher is specifically for finding Unicode characters by shape. If your goal is LaTeX commands for special symbols, the site points to Detexify instead. For other drawing-based tools, the approach differs by purpose — for example, MinecraftShapes.com generates pixel shapes for Minecraft builds, and Sketchful.io is a multiplayer drawing game — so match the tool to whether you need a character code, a build pattern, or entertainment.

Crossword Weaver is a Windows-only crossword puzzle maker that produces two distinct puzzle styles: free-form puzzles built from only your words, and themed symmetrical newspaper-style puzzles. It fits you if you work on Windows, want printable and playable output, and are willing to test the demo before deciding on a purchase. It is a weaker fit if you need macOS or web-based tools, or if you want a free alternative without evaluating paid software.

What Crossword Weaver Actually Does

Crossword Weaver is described as a tool for making two styles of crossword puzzles:

• Free-form puzzles — built using only your words, without forcing a symmetrical grid.
• Themed symmetrical newspaper-style puzzles — a more structured layout that resembles traditional published crosswords.

The software targets Windows only. Output is described as printable and playable, and the product is positioned as a maker, builder, and creator tool with automatic features. A demo is available so you can see whether it meets your needs before committing.

The Two Puzzle Styles, Compared

If your audience expects a classic newspaper look, the symmetrical style is the closer match. If you just want your own word list turned into a solvable puzzle with minimal layout fuss, free-form is the simpler path.

Platform and Compatibility Check

Before anything else, confirm you are on Windows. Crossword Weaver is Windows-only, so Mac, Linux, Chromebook, and browser-only workflows are out unless you have a Windows environment available. This is the single most common reason the tool is the wrong choice — not the puzzle features, but the operating system.

Evaluate With the Demo First

The site explicitly offers a demo to see if the software meets your needs. Use it to test the things that matter for your use case:

1. Build one free-form puzzle from a short word list and check the output.
2. Build one themed symmetrical puzzle and compare the layout to what you actually need.
3. Print or play the result to confirm the output format works for your audience.
4. Note any friction in the word-entry or layout process before deciding.

This demo-first path is the intended evaluation route, so treat it as the deciding step rather than relying on feature lists.

How It Compares to Alternatives

Use the same dimensions when weighing Crossword Weaver against other options:

• Platform: Crossword Weaver is Windows-only. Free web-based makers usually run in any browser but may offer less layout control.
• Puzzle styles: The two-style approach (free-form plus symmetrical themed) covers both casual and publication-style needs. Many simple free tools only do one style.
• Output: Printable and playable output is claimed here. Check whether an alternative gives you the same export and play options.
• Cost: Crossword Weaver involves a purchase. Free alternatives exist, so weigh the price against the layout control and Windows-native workflow you get.
• Evaluation: A demo lets you test before buying. Free tools need no commitment but also no trial period.

Which Choice Fits You

• Choose Crossword Weaver if you are on Windows, want both free-form and symmetrical themed puzzles, value printable and playable output, and are willing to try the demo and then purchase.
• Look elsewhere if you are not on Windows, need a free tool, or only need a single simple puzzle style that a browser-based maker already handles.

The deciding factors are platform, the two puzzle styles, and whether the demo output matches your audience or publication. Test those three before committing.

Start with the Get Started with Unity tutorial on Unity Learn, then set up Unity Hub and the Unity Editor before touching any other course. That tutorial is a guided tour of the Editor that ends with you creating your first 3D scene, so it gives you a working environment and a finished result in one sitting. From there, the fastest path is a guided Collection rather than jumping between unrelated tutorials — "Get your first game running" takes you from a blank Unity 6 project to a playable game and covers the editor, C# scripting, physics, and game design fundamentals across 9 resources.

Before you open any tutorial

Unity Learn's beginner Quick Guides assume you have the tooling in place. Do these first, in order:

1. Install Unity Hub — the launcher that manages Editor versions and projects. Unity Learn lists a 10-minute beginner tutorial, "Explore the Unity Hub," for this.
2. Set up the Unity Editor — a 15-minute beginner tutorial covers this. Note that Unity 6.6 is the current release referenced on the site.
3. Create a Unity ID and sign in — Unity Learn's welcome page prompts you to sign in, and course progress and submissions are tied to your account.

If you skip step 2, most tutorials will fail at the first instruction because menu items and project templates won't match what the instructor sees.

The recommended first sequence

Steps 1–3 are short and tooling-focused. Step 4 is where actual game development begins — it's the point where you stop following clicks and start making decisions about your own project.

Choosing a track after the basics

Once you have a playable game, pick a Collection that matches what you want to build. Unity Learn organizes these by goal, not by difficulty:

• Create a 2D game (6 resources) — sprites, physics, Tilemap, skeletal animation, and level design for platformers and roguelikes.
• Create a 3D Game (10 resources) — Rigidbody physics, C# scripting, enemy AI, and Cinemachine cameras for FPS and open-world games.
• Make your game look great (12 resources) — URP, Shader Graph, VFX Graph, real-time lighting, and post-processing.
• Ship your first mobile game (8 resources) — build setup, URP mobile optimization, Addressables, and Unity Gaming Services for iOS and Android.
• Build with Unity AI (10 resources) — the Unity AI Assistant, AI Gateway, and MCP Server inside the Unity 6 Editor, for writing scripts and debugging errors.

Pick one and finish it. Switching between the 2D and 3D tracks mid-way means re-learning a different physics and rendering setup for no benefit.

Pathways vs. Collections vs. courses

Unity Learn uses three formats, and they serve different purposes:

• Quick Guides — single-skill, 10–30 minute tutorials (Hub, Editor setup, publishing, Editor tips and tricks). Use these to unblock a specific tool.
• Collections — resources curated around a single goal, like getting your first game running. Use these when you know what you want to build.
• Pathways — longer guided learning experiences aimed at breaking into the gaming and real-time 3D industries, described as suitable regardless of prior experience. Use these if your goal is employment rather than a single finished project.
• Courses — in-depth topic coverage combining step-by-step tutorials and projects, and many include submissions where you apply what you learned.

Common places beginners get stuck

Starting with a course instead of the Editor setup. Courses assume a configured project. Do the 15-minute setup first.

Treating tutorials as videos to watch. Unity Learn tutorials are step-by-step and expect you to perform each action in the Editor. Reading without doing produces no working scene.

Jumping to "Make your game look great" too early. URP, Shader Graph, and VFX Graph are visual polish. They won't help if your game logic doesn't run yet.

Not finishing a Collection. The value of "Get your first game running" is that it connects editor, scripting, physics, and design into one artifact. Stopping at resource 4 leaves you with disconnected fragments.

What to do after your first complete game

Move to a project-based course in the track you chose, and use the submission feature where available — many courses include submissions so you apply the material rather than just follow it. If your goal is a job in games or real-time 3D, a Pathway is the better next step than another standalone tutorial.

A font is a digital file that tells software how to draw a set of characters; creating or editing one means designing outlines for each glyph and exporting those outlines in a format other programs can install and use. You can do this with a free, open-source outline editor such as FontForge, which supports OpenType, TrueType, UFO, and its own SFD format. This article explains the vocabulary, the common file formats, the basic design-to-export workflow, and the mistakes that most often break a first font.

Font, typeface, and font family: the terms people mix up

These three words describe different things, and mixing them up causes confusion when you start working in an editor.

• Typeface — the design itself: the shapes, proportions, and style of the letters. "Helvetica" as a design idea is a typeface.
• Font — the digital file that implements a typeface so a computer can render it. A .ttf or .otf file on your disk is a font.
• Font family — a group of related fonts that share a design but differ in weight or style, such as Regular, Bold, and Italic.

In everyday speech people say "font" for all three, but inside an editor the distinction matters: you design a typeface, you generate font files, and you organize those files into a family.

Common font formats you will meet

The practical split is source formats (UFO, SFD) versus output formats (OTF, TTF). You design and save in a source format, then export to an output format when the font is ready to install or ship. Keeping the source file is what lets you come back and fix a glyph later.

The basic workflow for designing a font

The steps below are the general shape of font creation; FontForge is one free outline editor that fits into this pipeline.

1. Set up the em square and metrics. Decide the design space — typically a 1000- or 2048-unit em — and define where the baseline, x-height, and cap height sit. Every glyph is drawn relative to these guides.
2. Draw the glyphs. Create outlines for each character. Start with a control set such as H, O, n, o, and e, because these establish the proportions the rest of the alphabet follows.
3. Add spacing and kerning. Set the left and right side bearings for each glyph, then adjust kerning pairs (for example AV or To) where the default spacing looks too loose or too tight.
4. Test at real sizes. Render sample text at small and large sizes to check that curves, stems, and spacing hold up.
5. Export to a usable format. Generate an OTF or TTF file, then install it to verify it behaves like any other font.

Each step feeds the next: bad spacing in step 3 shows up as uneven text in step 4, and a missing glyph in step 2 becomes a blank box after export.

Where a free outline editor like FontForge fits

FontForge is described as a free and open-source outline font editor. In the workflow above, it covers the drawing, spacing, and export stages, and it reads and writes OpenType, TrueType, UFO, and SFD files. That means you can:

• Start a new typeface from scratch and save it as SFD.
• Open an existing font, edit individual glyphs, and re-export it.
• Move design data between FontForge and other tools through UFO.

Because it is open source, there is no license cost to begin, and the source formats it uses are documented and portable. If your goal is simply to understand how fonts are built or to make a small custom font, an outline editor of this kind is enough to complete the whole pipeline.

Common pitfalls and how to avoid them

Most first-font problems fall into a few predictable categories.

• Missing glyphs. If a character has no outline, software shows a blank box or a fallback from another font. Check that every character you intend to support actually has a drawn glyph before exporting.
• Bad kerning. Default spacing rarely looks right for every pair. Test strings with awkward combinations like AV, Ta, and Yo, and add kerning pairs where they collide or drift apart.
• Export errors. A font can fail to generate if outlines are open, self-intersecting, or drawn in the wrong direction. Validate contours before exporting, and re-open the exported file to confirm it loads.
• Inconsistent metrics. If the baseline or x-height shifts between glyphs, text will look like it is bouncing. Set the guides once and draw everything against them.

What to do next

If you want to try this yourself, pick a small goal first — for example, redesign the letters of your own name or build a display font with just uppercase letters. Save your work in a source format as you go, export to OTF or TTF when you are done, and install the result to see how it behaves in a real document. That loop — design, save, export, test — is the same one professional type designers use, just at a smaller scale.