Copying Fonts in Illustrator: What Actually Happens When You Use Type to Create Outlines
Most people come to this feature thinking they are doing something magical with typography. They are not. You are converting text objects into vector shapes, which means the letters lose all their font data and become permanent paths. That is the entire mechanism. Everything else is just about knowing when it matters and when it does not. The process itself is straightforward enough that it barely needs explaining, but the implications of what you are doing are where most people make mistakes. Select your text object. Go to Type at the top of the screen and choose Create Outlines, or use the keyboard shortcut Shift plus Control plus O on Windows or Shift plus Command plus O on Mac. Illustrator will immediately replace the editable text with a group of compound paths. Each character becomes a filled shape. You can no longer change the spelling, the font size through the character panel, or any typographic property. The text is now geometry. From there, if your goal is to copy the visual appearance of a font without actually using the font file, you would select those outlined paths and move them into a new document or onto a different artboard. You could also use the Scissors tool or the Pathfinder panel to break apart individual characters and rearrange them. Some designers attempt to recreate font styles by tracing over glyphs manually, but that is a separate workflow entirely and usually not worth the time unless you are dealing with a highly specialized custom lettering project.
I ran into a specific problem last year that illustrates why this feature exists and why it still causes headaches. I was preparing artwork for a commercial print run where the client wanted to use a custom glyph set from a font that had licensing restrictions preventing embedding in the final PDF. The solution was to create outlines on every text element, which stripped the font data completely. But here is the issue: once outlined, the text no longer had any kerning pairs applied through the font's OpenType features. Ligatures disappeared. Certain glyph substitutions broke. I had to manually adjust the spacing on about forty text objects, which added roughly three hours to an otherwise quick turnaround. The workaround was to lock the original text layer, duplicate it, create outlines on the duplicate, and then use the original as a reference while I manually repositioned each outlined character. There is a nuance that beginners almost never catch. When you create outlines, the resulting paths retain the stroke and fill attributes of the original text, but they do not retain the font's inherent metric data. This means if you later need to resize those outlined letters proportionally, you are scaling a shape, not reflowing text. A 12 percent width reduction on outlined text will look squashed, while the same change on live text would trigger automatic kerning and spacing adjustments through the font's internal table. This is why outlined text is generally fine for logos and static design elements but terrible for anything that needs responsive scaling or editing. Another thing that is not obvious is how Illustrator handles different text types differently during the outline process. Paragraph text blocks with soft returns will convert into individual compound paths grouped together, but the return itself disappears. The layout breaks apart completely. Body copy on a page becomes uneditable shapes scattered across the artboard with no paragraph formatting remaining. This is intentional, but it catches people off guard every time. Headlines and short text strings behave better because there is less structural complexity to collapse. If you are working with a multi-paragraph document and accidentally hit Create Outlines, you are going to spend a significant amount of time reconstructing the layout.
The real power of this feature shows up in production workflows rather than creative exploration. When you send files to external printers, manufacturers, or clients who may not have your fonts installed, outlining ensures the text renders exactly as you designed it regardless of their system. This is standard practice in packaging design, signage production, and any workflow where color accuracy and text integrity cannot be left to chance. The tradeoff is that you lose editability, so you should always keep a backed-up version of your file with live text before you commit to outlines. I keep a separate .ai file for the editable source and export a second version specifically for production delivery. One more detail worth noting: if you have OpenType features enabled on your live text before outlining, such as stylistic alternates or contextual ligatures, those features are baked into the resulting shapes. The outlined paths will reflect whichever glyph variant was actively displayed at the moment of conversion. This is actually useful because it locks in the exact visual you see on screen, but it also means if you switch glyph variants after outlining, you cannot go back. The original font metrics and alternate glyphs are no longer accessible. There is no software download required for this functionality. It is built directly into Adobe Illustrator as a native Type menu command. All versions of Illustrator from CS2 onward support it, and the behavior is essentially identical across current releases. If you are using an older version like CS6, the interface location is the same but the outline quality on certain complex glyphs can be slightly coarser compared to Illustrator CC 2020 and later, where the conversion algorithm produces cleaner path intersections and fewer stray anchor points.
Get the Full Details
The limitation nobody wants to hear about is that outlining is destructive and irreversible without undoing multiple steps. If your document has ten layers with different text objects spread across them, and you outline everything at once, you cannot selectively revert one layer without restoring from a backup. The undo history does not distinguish between live text and outlined text once the command is executed. I learned this the hard way on a project where I outlined text on a master file that was also being used as a template for a series of variants. The entire template became non-editable, and I spent an afternoon rebuilding text layers from scratch. Now I outline only the final delivery file and keep the template locked in a separate document. If your goal is simply to change the visual weight or style of text without committing to outlines, there are better approaches. Copying a font file into your system folder and installing it gives you the full typographic capabilities including kerning, ligatures, and variable weight support. That is the standard route for designers who need flexibility. Outlining is the exception, not the rule, and it should be treated as a production step rather than a creative one.
When Outlining Text Makes Sense and When It Does Not
The decision to convert text to outlines should be based on output requirements, not convenience. If the deliverable is a PDF for print, a vector file for an external vendor, or a logo that will be scaled across different media, outlining is the correct choice. If the deliverable is an interactive web design, a document that needs editing, or a layout that will go through multiple revision cycles, keep the text live. The difference in workflow efficiency between these two approaches is substantial. Live text allows you to update copy, adjust spacing, and modify styles in minutes. Outlined text requires manual intervention for every single change, which can add hours to a project depending on volume. I have found that the most efficient approach is to work entirely in live text through the design phase, then create a separate prepared file for final output where you apply outlines only to the text that needs it. This way your creative work remains flexible and your production file is locked in with the correct visual output. The two-file system adds about ten minutes of setup time but saves multiple hours over the life of a project. That is the practical reality of how this feature is used in professional environments.
