Quantcast
Channel: Glyphs News, Events and Tutorials
Viewing all 502 articles
Browse latest View live

18–28 April 2017: Curso Diseño Tipográfico en Valencia

0
0

Una buena oportunidad para aprender todo lo necesario acerca del proceso de diseño tipográfico, desde la caligrafía y el lettering a la tipografía digital en Glyphs. Matricúlate ya!

Curso de introducción al diseño de Tipos

Hemos preparado un fantástico curso de diseño tipográfico en el que contaremos con Joan Quirós, Rafael Jordán y Raul Climent Rojano de Menta.


New Apps: MergeGlyphs, CommitGlyphs, TextPreview, FontTableViewer

5–7 May 2017: Glyphs Workshop at Design Festival, Bern

0
0

The lovely folks of TypeWorks will conduct a Glyphs workshop at this year’s Design Festival Bern. Don’t miss this!

Einführung in die Schriftgestaltung mit Glyphs

Du wolltest schon immer eine eigene Schriftidee umsetzen oder beispielsweise deine Handschrift digitalisieren? In diesem Workshop vermitteln wir die Herangehensweisen und Prinzipien der Schriftgestaltung. Du erhältst einen Einblick in den Gestaltungsprozess von der Skizze bis zur professionellen Digitalisierung mit der zeitgemässen Schriftgestaltungssoftware GlyphsApp.

7–9 July 2017: Love Letters Workshop in Brussels

0
0

Que vous soyez débutant ou que vous ayez déjà un projet avancé, Love-letters vous invite à participer à son workshop de création de caractères typographiques.

Love Letters

  • When?

    Vendredi 7 – dimanche 9 juillet
    9:00 – to 18:00

  • Who?

    Sébastien Sanfilippo

  • Where?

    La Villa Hermosa
    Rue de Laeken 101
    1000 Bruxelles

  • How much?

    EUR 310
    Students: EUR 160

  • For whom?
  • Prerequisites
  • Links

    Love Letters

Au cours du workshop, vous acquerrez les principes du dessin de lettres d’après l’analyse de modèles historiques et contemporains. Vous serez accompagné dans la création et le développement de votre projet personnel. En fonction des besoins de votre projet, vous vous familiariserez avec les outils de la création d’une typographie digitale comme la vectorisation, les courbes de Bezier, les approches de lettres, le kerning, l’interpolation et le workflow.

16 May–14 June 2017: Type Design Workshop in Toronto, 2017

0
0

CanadaType designer Kevin King will hold a five-week workshop in Toronto, starting next week. Be quick and sign up for the last remaining seat!

Type Design Workshop with Kevin King

  • When?

    Tuesdays & Wednesdays, 6–9pm,
    May 16th until June 14th

  • Who?

    Calligrapher​, type designer and typographer​ Kevin King (CanadaType)

  • Where?

    Coach House Press in Toronto, Canada

  • How much?

    This workshop will cost CAD 390.

  • For whom?
  • Prerequisites

    .Required supplies will be a laptop computer with Glyphs installed. An extended trial license will be made available.

  • Links

This 5-week workshop focuses on the conceptualization and creation of a usable typeface, guiding participants through the process of digitizing letterforms, spacing and kerning, and OpenType feature coding.

23–26 August 2017: Cyrillic Workshop at Typeworks Bern

0
0

The lovely folks of TypeWorks are organizing a Cyrillic type design workshop in Bern. Don’t miss this! Award-winning type designers Maria Doreuli and Krista Rodoeva (Cyrillicsly) will be your mentors. As always, workshop participants receive an extended trial license and are entitled to a 10% discount for Glyphs.

Cyrillic Type Design at Typeworks

  • When?

    23-26 August, 2017

  • Who?

    Maria Doreuli (Contrast Foundry, Moscow) and Krista Radoeva (Fontsmith, London)

  • Where?

    Erlesen, at Progr, Bern

  • How much?

    CHF 500 (CHF 280 students)
    Early bird: CHF 450 (250) until 18 June!

  • For whom?

    Students, professionals and typographic enthusiasts.

  • Prerequisites

    Bring your own MacBook, sketchbook and writing tools. Glyphs trial download

  • Links

    Typeworks

Through a combination of lectures, group exercises, independent work and feedback sessions, the participants will design a Cyrillic extension to their own Latin fonts. The mentors will provide an in-depth look into history, writing, calligraphy and the contemporary state of the Cyrillic script in order to develop an understanding of the basic structure of letterforms. Focusing on the common approaches for designing Cyrillic, this workshop will provide a well structured knowledge on the logic behind the key letters of the script.

Besides the basic Cyrillic, participants will be paying attention to the country-specific alternatives. The mentors will share with the participants the research on the extended Cyrillic — not only Bulgarian and Serbian localised forms, but a huge amount of mysterious letters that are being used in hidden parts of Russia and in many of the post-Soviet countries.

Scripting Glyphs, Part 4

0
0

This tutorial is part 4 of a series of tutorials and therefore assumes that you have read part 1, part 2 and part 3. This is what we have so far:

#MenuTitle: Glyph Shaker
# -*- coding: utf-8 -*-
__doc__="""
Goes through all selected glyphs and slaps each of their nodes around a bit.
"""

import random
random.seed()

selectedLayers = Glyphs.font.selectedLayers

for thisLayer in selectedLayers:
    for thisPath in thisLayer.paths:
        for thisNode in thisPath.nodes:
            thisNode.x += random.randint( -50, 50 )

So far, so good. I think it is pretty easy to read through it and understand what the code does. It is not that complicated, after all. Still, I want to point you to a few aspects for keeping the oversight in your scripts. First, look at this line:

selectedLayers = Glyphs.font.selectedLayers

This is equivalent to:

currentFont = Glyphs.font
selectedLayers = currentFont.selectedLayers

The first version keeps everything compactly on one line, the second version splits the content into two lines. Performance-wise, there is not really any difference between the two. So either way is fine. However, there are a few arguments for the second solution:

  • Firstly, you may want to reuse currentFont several times at a later stage.
  • Secondly, debugging is easier. If there is a typo and Glyphs reports an error, it is easier to spot the mistake in short lines. Remember that error messages always report the line number. In our example, the problem could lie either in accessing the current font or in accessing its selected layers. In the first solution, you would not know which, and would have to do some searching on your own. In the second solution, the reported line number directly points you to the problematic part, and you know right away what is going on.
  • Thirdly, the second solution keeps your code more legible. This will become very important when you go hunting for a bug.

Yes. Keep your code legible. You will deal with it at a later time. Or worse, you will have to ask someone else to look at your code, and then it is a very, very good idea to keep your code legible. For better code legibility, you will find many tips throughout the internets (Google is your friend), but for our purposes, always remember these things:

  • Keep your variable names clear and legible. Use speaking names like currentFont rather than f or currF.
  • As explained above, reserve one line per action. Do not squeeze three steps into one line.
  • Move distinguishable sets of actions into functions. Avoid creating long sequences of steps, a.k.a. ‘spaghetti code’.

Functions

What? Make my own functions? We talked a little bit about Python’s built-in functions in part 2 of this tutorial, but we have not made our own functions yet. Admittedly, for our script, it was not really necessary yet.

But consider the possibility that we want to expand the script because we want to do more than just slapping the nodes horizontally. For instance, we could also rotate the glyph a little, or randomly move it up and down, or skew it, or randomly add or subtract a few extra paths. Consider our loop:

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer)
    rotateLayerRandomly(thisLayer, 5)
    randomVerticalMove(thisLayer, 100)

Looks clean and clear, right? Not really sure what the numbers in the parentheses are about, but otherwise we’re cool: we loop through each thisLayer in selectedLayers, then we slap nodes around randomly, then we rotate the layer randomly by up to 5 degrees, and finally we randomly move the whole glyph layer up or down by up to 100 units. We have not written any code for this yet, but we can already see what we are doing, simply from looking at the function names: slapNodesRandomly(), rotateLayerRandomly() and randomVerticalMove().

So, how do we make a new function? Easy, with the def statement! A function has to be defined before it is called for the first time. So, right before the loop, we insert our function definition:

def slapNodesRandomly(thisLayer):
    for thisPath in thisLayer.paths:
        for thisNode in thisPath.nodes:
            thisNode.x += random.randint( -50, 50 )

The word after def, is the function name, in our case slapNodesRandomly. It must be followed by parentheses () which can contain variable names, so-called arguments, in our case thisLayer. The parentheses are very important, because they differentiate variable names from function names. In other words, when we refer to this function, we would not just call it slapNodesRandomly, but more specifically: slapNodesRandomly(). So everyone knows it is a function we are talking about and nothing else.

In our case, the function contains one argument, thisLayer, which refers to the value that will be passed to it. The variable is local, i.e., it only is valid and accessible inside the function. That means that the word thisLayer has a different meaning inside the function (local function variable) than outside the function (global script variable). To make this distinction more clear, some coders like to apply different variable naming conventions inside functions, e.g., myLayer instead of thisLayer.

Now, all we have to do in our loop through selectedLayers is simply call the function:

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer)

This calls the function, and between parentheses, it passes an argument to the function, the global variable thisLayer. And the slapNodesRandomly() function does the same thing we used to have spelled out in the loop. But now, we are ready to expand our script with more functionality, and keep the oversight.

Before we do this, let’s recap. This is our current status quo:

#MenuTitle: Glyph Shaker
# -*- coding: utf-8 -*-
__doc__="""
Goes through all selected glyphs and slaps each of their nodes around a bit.
"""

import random
random.seed()

selectedLayers = Glyphs.font.selectedLayers

def slapNodesRandomly(thisLayer):
    for thisPath in thisLayer.paths:
        for thisNode in thisPath.nodes:
            thisNode.x += random.randint( -50, 50 )

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer)

Abstraction

In the world of coding, abstraction means that you take a function and make it more configurable, i.e., fit for more purposes and applications. When we take a look at the current code, slapNodesRandomly() only changes x coordinates of all nodes by up to 50 units. We could make the function more abstract by also offering changing of y coordinates, and allowing other maximum values besides 50. Let’s do just that: First we add extra arguments into the parentheses, and while we’re at it, we also supply default values:

def slapNodesRandomly(thisLayer, maxX=50, maxY=0):

Two things to remember about this: arguments must be comma-separated, and arguments with a default value (a.k.a. ‘keyword arguments’) come after normal arguments. The default values are supplied after an equals sign.

You can still call slapNodesRandomly() the way we are used to. But you can also supply new values and override the defaults. Here are all our options when it comes to calling our function:

  • slapNodesRandomly(thisLayer), because you do not need to supply keyword arguments since they can fall back onto their default values: maxX is 100, and maxY is zero.
  • slapNodesRandomly(thisLayer, 100) which means that maxX is 100, but maxY still takes its value from the default zero.
  • slapNodesRandomly(thisLayer, 90, 80) calls the function with 90 for maxX and 80 for maxY.
  • slapNodesRandomly(thisLayer, maxY=70) skips maxX so it gets its default of 100, but sets maxY to 70. Keyword arguments can either be unnamed and in the predefined order (as in the two examples above), or named and in any order, as long as they come after the required normal arguments, in this case after thisLayer.

Of course, we still have to change a few lines to make use of the abstraction. First the line that moves the nodes randomly has to be expanded into two lines, and instead of fixed values, we insert our keyword arguments:

            thisNode.x += random.randint( -maxX, maxX )
            thisNode.y += random.randint( -maxY, maxY )

So, the complete function looks like this:

def slapNodesRandomly(thisLayer, maxX=50, maxY=0):
    for thisPath in thisLayer.paths:
        for thisNode in thisPath.nodes:
            thisNode.x += random.randint( -maxX, maxX )
            thisNode.y += random.randint( -maxY, maxY )

Congratulations, you have successfully abstracted our function. Now we can change the line where we call it:

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer, maxX=70, maxY=70)

Now open a font you don't like, select all its glyphs, and let the script do its magic. Har har.

Affine Transformations: Shift

Now that we cleaned up the loop, it should be easy to add new functions. Let’s start with one we mentioned already, randomVerticalMove(). It should randomly move the whole glyph layer up or down. So we know we need two arguments: the layer and the maximum shifting distance. This could be the first line of our function, then:

def randomVerticalMove(thisLayer, maxShift=100):

Next thing, we need to get a random number between negative maxShift and positive maxShift:

    shift = random.randint( -maxShift, maxShift )

And now we need to apply that shift to the whole layer, including nodes, anchors and components. If you look closely on docu.glyphsapp.com, at the methods a GSLayer has, you will find a function called GSLayer.applyTransform() and it takes the six numbers of an affine transformation matrix as an argument. In case your highschool math is just too long ago, this is the meaning of the 6 numbers:

  1. Horizontal scale from the origin: 1.0 (means no change)
  2. Horizontal shear from the origin: 0.0
  3. Vertical shear from the origin: 0.0
  4. Vertical scale from the origin: 1.0
  5. Horizontal shift: 0.0
  6. Vertical shift: 0.0

In other words, a matrix that does nothing looks like [1, 0, 0, 1, 0, 0] and if we want to shift the layer vertically, we need to change the last number. In our case we would just have to insert our variable shift, i.e., [1, 0, 0, 1, 0, shift] is our matrix. That’s it. So the rest of our function looks like this:

    shiftMatrix = [1, 0, 0, 1, 0, shift]
    thisLayer.applyTransform( shiftMatrix )

OK, recap. Our function looks like this:

def randomVerticalMove(thisLayer, maxShift=100):
    shift = random.randint( -maxShift, maxShift )
    shiftMatrix = [1, 0, 0, 1, 0, shift]
    thisLayer.applyTransform( shiftMatrix )

And our loop is now expanded to this:

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer, maxX=70, maxY=70)
    randomVerticalMove(thisLayer, maxShift=200)

In the last line, we call the randomVerticalMove() function, and pass two arguments: the layer we are just looping through, and the maximum shift we allow. To make it more fun, I chose 200 instead of the default 100.

Affine Transformations: Rotate

How about rotating? Sounds cool, but there is no rotation in the matrix, right? No problem if you remember your last year of math at school: rotation can be achieved through a combination of shearing horizontally and vertically plus some compensatory scaling. If you like, you can dive back into trigonometrical calculations, but I will cut the story short and give you the matrix: For rotating around the origin point by an angle a, you need the matrix: cos(a), −sin(a), sin(a), cos(a), 0, 0.

So, all is set now, right? All we need to do is calculate the angle, fill it into that matrix, and apply the affine transformation, done. Well… not quite. Remember all transformations are happening around the origin point. If we want to rotate around a better pivot point, like the center of the layer bounds, we need to shift the whole layer content onto the origin point, then rotate, and finally shift everything back to its original position. Makes sense? OK, here we go:

def rotateLayerRandomly(thisLayer, maxAngle=5):

First thing we need to do is find the center of the layer and move it onto the origin point. Luckily, the layer has an attribute called bounds, and bounds has two attributes, origin and size. Digging deeper, we find that origin has x and y as attributes, while size has both width and height. To calculate the center, we need to start at the origin point, and add half the width and half the height. This is what the following two lines do:

    xCenter = thisLayer.bounds.origin.x + thisLayer.bounds.size.width * 0.5
    yCenter = thisLayer.bounds.origin.y + thisLayer.bounds.size.height * 0.5
    shiftMatrix = [1, 0, 0, 1, -xCenter, -yCenter]
    thisLayer.applyTransform( shiftMatrix )

And the two lines after that construct the transformation matrix for shifting the layer content on top of the origin point.

Now it is time to rotate. In other words, we need to first calculate a random angle between the negative and positive maximum, then construct and apply another transformation matrix with the sine and cosine of the angle. The random number part is easy:

    angle = random.randint( -maxAngle, maxAngle )

Now, how do we get the cosine and sine for that angle? In Python, there is a module for anything beyond the most basic mathematics, and it is called math. We can import it like we imported random before, and then we can access its functions. First, we need to expand the import line to also include the math module:

import random, math

Let’s see what math has in terms of trigonometric functions. In a new Python window in TextEdit or SublimeText, or the Glyphs Macro Window, type this and run it:

import math
help(math)

And you will see a lot of output, amongst which the definitions of two functions called sin() and cos(). To narrow down the help output, run this:

import math
help(math.sin)
help(math.cos)

And you should receive this output:

Help on built-in function sin in module math:

sin(...)
    sin(x)

    Return the sine of x (measured in radians).

Help on built-in function cos in module math:

cos(...)
    cos(x)

    Return the cosine of x (measured in radians).

OK, so that means that we can run math.cos(x) and math.sin(x), provided x is measured in radians. Wait a minute, our angle is measured in degrees, so we need to convert it to radians first. Luckily, there is also a radians() function in the math module. To find out more about it, we can run help(math.radians):

Help on built-in function radians in module math:

radians(...)
    radians(x)

    Convert angle x from degrees to radians.

Phew. So, let’s continue in our rotateLayerRandomly() function. First we need to make the radians conversion, then build and apply the matrix:

    angleRadians = math.radians( angle )
    rotationMatrix = [cos(angleRadians), -sin(angleRadians), sin(angleRadians), cos(angleRadians), 0, 0]
    thisLayer.applyTransform( rotationMatrix )

Did we forget anything? Of course! We need to move the whole thing back from the origin to its original position! In other words, the reverse of what we did before:

    shiftMatrix = [1, 0, 0, 1, xCenter, yCenter]
    thisLayer.applyTransform( shiftMatrix )

But I think that’s it. Let’s recap. Here is our function:

def rotateLayerRandomly(thisLayer, maxAngle=5):
    # move on top of origin point:
    xCenter = thisLayer.bounds.origin.x + thisLayer.bounds.size.width * 0.5
    yCenter = thisLayer.bounds.origin.y + thisLayer.bounds.size.height * 0.5
    shiftMatrix = [1, 0, 0, 1, -xCenter, -yCenter]
    thisLayer.applyTransform( shiftMatrix )

    # rotate around origin:
    angle = random.randint( -maxAngle, maxAngle )
    angleRadians = math.radians( angle )
    rotationMatrix = [ math.cos(angleRadians), -math.sin(angleRadians), math.sin(angleRadians), math.cos(angleRadians), 0, 0 ]
    thisLayer.applyTransform( rotationMatrix )

    # move back:
    shiftMatrix = [1, 0, 0, 1, xCenter, yCenter]
    thisLayer.applyTransform( shiftMatrix )

I added comments for clarity. And our loop now looks like this:

for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer, maxX=70, maxY=70)
    randomVerticalMove(thisLayer, maxShift=200)
    rotateLayerRandomly(thisLayer, maxAngle=15)

And, our last recap for now, the whole script looks like this now:

#MenuTitle: Glyph Shaker
# -*- coding: utf-8 -*-
__doc__="""
Goes through all selected glyphs, slaps their nodes around, rotates them a little, and shifts them up or down a little.
"""

import random, math
random.seed()

def slapNodesRandomly(thisLayer, maxX=50, maxY=0):
    for thisPath in thisLayer.paths:
        for thisNode in thisPath.nodes:
            thisNode.x += random.randint( -maxX, maxX )
            thisNode.y += random.randint( -maxY, maxY )

def randomVerticalMove(thisLayer, maxShift=100):
    shift = random.randint( -maxShift, maxShift )
    shiftMatrix = [1, 0, 0, 1, 0, shift]
    thisLayer.applyTransform( shiftMatrix )

def rotateLayerRandomly(thisLayer, maxAngle=5):
    # move on top of origin point:
    xCenter = thisLayer.bounds.origin.x + thisLayer.bounds.size.width * 0.5
    yCenter = thisLayer.bounds.origin.y + thisLayer.bounds.size.height * 0.5
    shiftMatrix = [1, 0, 0, 1, -xCenter, -yCenter]
    thisLayer.applyTransform( shiftMatrix )

    # rotate around origin:
    angle = random.randint( -maxAngle, maxAngle )
    angleRadians = math.radians( angle )
    rotationMatrix = [ cos(angleRadians), -sin(angleRadians), sin(angleRadians), cos(angleRadians), 0, 0 ]
    thisLayer.applyTransform( rotationMatrix )

    # move back:
    shiftMatrix = [1, 0, 0, 1, xCenter, yCenter]
    thisLayer.applyTransform( shiftMatrix )

# loop through all selected layers:
selectedLayers = Glyphs.font.selectedLayers
for thisLayer in selectedLayers:
    slapNodesRandomly(thisLayer, maxX=70, maxY=70)
    randomVerticalMove(thisLayer, maxShift=200)
    rotateLayerRandomly(thisLayer, maxAngle=15)

OK, I admit that I cleaned up some more: I updated the doc string, I moved the selectedLayers assignment to right in front of the loop, and I added some comments here and there.

And you see I have been a little inconsistent when it comes to extra spaces I leave between parentheses or brackets and their respective content. It doesn’t really matter, it is a matter of coding style, and I sometimes leave extra spaces for increased legibility. But I have been accused of sloppiness because of this, so you may want to be more consistent about it than I am.

And let’s see what it does to a font: Save the script, open a font you never really liked that much, select a few glyphs, and run the Glyph Shaker script again from the Script menu. This is what happens:

Ha, cool. Experiment with the values you pass to the functions and give those fonts hell. Have no mercy.

24 July–4 August 2017: Type Design Intro at Zurich Typo Summer

0
0

Spend two Summer weeks in Zürich working on your first typeface under the guidance of two experienced Swiss type designers. This and other great Stuff is happening during Typo Summer in Switzerland.

Workshop ‘The Fundamentals of Type Design’

  • When?

    24 July – 4 August
    Monday through Friday, 9.00–17.00 h

  • Who?

    Jonas Niedermann
    Anton Studer

  • Where?

    Zürich, precise location t.b.a.

  • How much?

    CHF 1400

  • For whom?

    All designers interested in type

  • Prerequisites

    Pencil, paper, MacBook with Glyphs 2 preinstalled

  • Links

Initially, we write letters of the Latin alphabet with pencil, quill pen and brush. This provides an awareness of form, proportion, and rhythm of characters. Stroke widths, stems, hairlines, diagonals, curves, as well as terminals and serifs are discussed and practiced. Design approaches are formulated and revised until the font’s basic features, proportions, and nature are defined.
After an introduction to the font design software ‘Glyphs’, the design drafts are digitized. In a systematic approach, the font is extended to a complete character set, until a text with a pleasing appearance can be set.
Daily mentorship and feedback will accompany the design and implementation process.
Each participant should take away profound technical knowledge and their own font, ready for application.


New Tool: EditGlyphData

0
0

EditGlyphData is our latest addition to our nice little set of tools. It is a simple and straight-forward XML editor for glyph data. You can easily create new glyph entries, merge other glyph data into your glyph data, and never have to worry about XML file consistency anymore!

If you have not done so yet, head on over to the Tools section of our website and give the tools a spin. And have all the glyph data fun you can have with EditGlyphData!

31 July–13 August 2017: Summer Workshop with Luc(as) de Groot in Bulgaria

0
0

Starting with sketches and ending with font files, each participant will understand the logic and principles behind the long process of developing a typeface. Expect fourteen intensive days of practical exercises, theoretical lectures and discussions on important issues related to the design and production of a typeface. Each participant will benefit from the in-depth knowledge of one of the most respected masters of type design in the world.

Participants will receive an extended Glyphs trial license and a discount for the full version.

Eye-Opener in Type Design

  • When?

    31 July through 13 August, 2017

  • Who?

    Luc(as) de Groot

  • Where?

    Bozhentsi Architectural and Historical Reserve, near Gabrovo

  • How much?

    EUR 500

  • For whom?

    both for beginners and for the more experienced

  • Prerequisites

    — pens, markers, pencils and erasers
    — MacBook with a font editor such as Glyphs and a vector app (like Illustrator)

  • Links

    FaceBook page for Eye Opener in Type Design

The classes will include theoretical lectures and many practical exercises related to the following topics:
— Analog and digital font history.
— Writing with the broad and pointed nib.
— Sketching and peculiarities of the various characters.
— Digitization and quality of curves
— Vector and font file formats.
— Proportions, contrast and optical laws.
— Working with components and overlaps.
— Rhythm, spacing, metrics, kerning, and class kerning.
— MultipleMaster and interpolation.
— OpenType and other extras.
— Rasterization, PS and TTF hinting.
— Production of OTF, TTF, WOFF and WOFF2.

15–18 June 2017: Typographics 2017

0
0

At this year’s Typographics Festival, we will be present at Matteo bologna’s workshop (14 June) and the TypeLab (15–18 June). See below for details.

Full-Day Workshop: Type Design for Non-Type Designers

  • When?

    Wednesday 14 June
    9:00 am – 6:00 pm

  • Who?

    Matteo Bologna
    Glyphs team members Rainer Scheichelbauer and Georg Seifert will be present too.

  • Where?

    The Cooper Union
    41 Cooper Square
    New York, NY 10003

  • How much?

    USD 280

  • For whom?

    No prior experience is required in font design, but some experience with Bézier-based vector drawing tools is useful.

  • Prerequisites

    Bring your MacBook (macOS 10.9+) with Glyphs 2 preinstalled

  • Links

    http://2017.typographics.com/workshops/

Get a crash course in designing type from Matteo Bologna, Creative Director of award-winning studio Mucca Design. The workshop will introduce you to the basic skills necessary for the wild journey into the super fun world of type design and you will learn the basics of designing and generating a typeface.

TypeLab Presentation: Glyphs

  • When?

    Saturday 17 June
    13:30–14:00

  • Who?

    Rainer Erich Scheichelbauer
    Georg Seifert

  • Where?

    The Cooper Union
    41 Cooper Square
    New York, NY 10003

  • How much?
  • For whom?
  • Prerequisites
  • Links

    http://2017.typographics.com/typelab/

The status of type design in Glyphs: sit back, relax, and see what Glyphs can do at the moment. Plus: a few of the latest developments you probably have not seen or heard about yet.

TypeLab Workshop: Glyphs

  • When?

    Saturday 17 June
    15:00–17:30

  • Who?

    Rainer Erich Scheichelbauer
    Georg Seifert

  • Where?

    The Cooper Union
    41 Cooper Square
    New York, NY 10003

  • How much?
  • For whom?
  • Prerequisites
  • Links

    http://2017.typographics.com/typelab/

9–11 June 2017: ISType 2017

0
0

At this year’s ISType, Laurence Penney and the Glyphs team will guide you through the creation of a font family as an OpenType Variable Font. And, find a great new Glyphs goody in the tote bag…

Workshop: Glyphs & Variable Fonts

  • When?

    Sunday June 11
    10.00 – 16.00

  • Who?

    Laurence Penney
    Rainer Erich Scheichelbauer
    Georg Seifert

  • Where?

    SALT Galata

  • How much?
  • For whom?

    Anyone interested in fonts. No prior knowledge of type design necessary.

  • Prerequisites

    MacBook with OS X 10.9.5 or later. Make sure the trial version of Glyphs 2 is installed. Download it for free from http://updates.glyphsapp.com/latest2.php. Workshop participants are eligible for a discount on the full app license.

  • Links

    All info on the workshop page

This workshop will introduce you to font family design with multiple masters. We start by sketching and digitising a handful of light letters. In a second step, we will create a bold counterpart for each letter, and start interpolating between the two. You will learn how to create and produce a font family, both as separate font files, and as a variable font.

In the afternoon we’ll start with a background on variable font technology, focussing on the OpenType 1.8 format. You’ll learn how it works at a deep level using developer tools. You’ll try variable fonts (including your own, made with Glyphs) in the interactive Axis-Praxis website, and make a new website that uses multiple instances of one variable font instead of many separate fonts.

The Glyphs Smartphone Stand

0
0

We are happy to announce our new conference goody: a foldable smartphone stand made from beautiful green cardboard! Fold up – slide in – watch film: the smartphone stand for everyone. Watch out for the great conferences we will be appearing at in the coming weeks and months. The first goody bag you will find it in is the one of ISType 2017, next week in Istanbul.

Here’s how to put it together:

1. Fold

Fold along the lines:

  • Fold towards you at dashed lines.
    This is also known as Valley Fold, i.e., the dashed lines form a valley or groove.
  • Fold away from you at dotted lines.
    This is known as a Mountain Fold, i.e., the dotted lines form the peak.

If everything went right, your card now looks like this:

2. Close

Now, please pay close attention, because this is the most difficult part of the whole procedure. Slip the end that says ‘Put your smartphone here’ into the gap that has formed at the other, triangular, end:

That’s it, you made it! Now you’re done:

3. Slide in, Watch Film

Slip your smartphone in and enjoy a movie or your favourite YouTube or Vimeo channel. Or, what I like to do when I am lonely in a conference hotel room and cannot sleep: I watch Juan Pablo De Gregorio’s Glyphs videos.

And, of course, you can use it for turning your iPhone into a secondary display with the Glyphs Viewer app.

Credits

We want to express our thanks to Thomas ‘Dr. Typo’ Maier, who developed the fantastic fold structure, and to the great people at Infinitive Factory in Graz, Austria, who printed and produced the smartphone stands.

5–8 August 2017: Glyphs at Typetersburg 2017

0
0

Glyphs member Rainer Erich Scheichelbauer will be present at this year’s edition of Typetersburg, with an on-stage presentation and two workshops.

More Fonts, More Fun: from Gamification to Animation

  • When?

    Main Conference Program (5-6 August)

  • Who?

    Rainer Erich Scheichelbauer

  • Where?

    Artplay Spb.
    Konnogwardeiskaya 3E
    St.Petersburg, Russia

  • How much?
  • For whom?
  • Prerequisites
  • Links

New technologies create new possibilities. In this tour de force presentation, you will see proofs of concepts for what OpenType features and the latest Variable Font technology can do for you.

Beginners’ Workshop: Introduction to Type Design with Glyphs 2

  • When?

    7 August 2017
    12:00 – 19:00

  • Who?

    Rainer Erich Scheichelbauer

  • Where?
  • How much?

    RUB 3800

  • For whom?

    Beginners’ Workshop: No prior experience necessary.

  • Prerequisites

    Bring a MacBook with macOS 10.9.5 or later, download the free Glyphs 2 trial from glyphsapp.com/buy. Participants can purchase the full version at a discount.

  • Links

In this workshop, you will sketch your own typeface, digitize a few letters, add hinting, code an OpenType feature, produce a font, and test it on-screen.

Advanced Workshop: Multiple Masters and Variable Fonts with Glyphs 2

  • When?

    8 August 2017
    12:00 – 19:00

  • Who?

    Rainer Erich Scheichelbauer

  • Where?
  • How much?

    RUB 3800

  • For whom?

    Advanced Workshop: Some prior experience in type design required, no matter in which font editor.

  • Prerequisites

    Bring a MacBook with macOS 10.9.5 or later, download the free Glyphs 2 trial from glyphsapp.com/buy.
    Participants can purchase the full version at a discount.

  • Links

In this workshop, you will set up an interpolation, and create both a Multiple Master family and a variable font from it.

15–16 July 2017: Font Diner Workshop in Eau Claire, Wisconsin

0
0

From the Font Diner website: ‘After over 20 years in business, the Font Diner is pleased to announce, for the first time ever, we’re offering our very first workshops on font design and font making!’

Rare chance! If you are in Wisconsin and you miss this, it’s your own fault.

Font Making Workshop

  • When?

    15-16 July 2017

  • Who?

    Stuart Sandler & Dathan Boardman

  • Where?

    Eau Claire, Wisconsin

  • How much?

    USD 120 (Students: USD 100)

  • For whom?

    Maximum Participants: 16

  • Prerequisites

    Some experience in Adobe Illustrator useful. Bring your own MacBook (macOS 10.9+) with the trial of Glyphs 2 installed.

  • Links

    https://www.fontdiner.com/workshops/

This intensive two day workshop is perfect for designers who want to learn how to make their very first font! You’ll bring a photographic reference for an all caps font you want to create and the first day will be totally focused on vector letter tracing/drawing basics. On day two, we’ll switch gears and spend the day importing your letters, spacing, kerning and generating your first font!

You’ll leave with a strong foundation how to develop your own typefaces and how to expand on the font you’ve created at this workshop to use as you wish!


11–13 August 2017: Font Diner Route 66 Safari and Workshop

0
0

Three days Route 66, three days old signage, three days font making. This is one of the coolest workshops we have advertised on this site, and the price is a steal. Do not miss this, seriously.

I mean, seriously.

Route 66 Sign Safari & Font Making Workshop

  • When?

    11-13 August 2017

  • Who?

    Stuart Sandler & Dathan Boardman

  • Where?

    St.Louis, Missouri

  • How much?

    USD 240 (Students: USD 200)

  • For whom?

    Maximum Participants: 36

  • Prerequisites

    Some experience in Adobe Illustrator useful. Bring your own MacBook (macOS 10.9+) with the trial of Glyphs 2 installed.

  • Links

    https://www.fontdiner.com/workshops/

Established in 1996 with over 1,200 fonts under our belt, nothing gets us more excited at the Font Diner than hitting the open road and laying our eyeballs on the actual signage and ephemera that has inspired our retro American display font library. We’re excited to bring that experience to you as we teach you how to make you make your very own font! We’re not talking a few words or letters, but an actual typeable font you can use for your very own projects or use as you wish!

The main reason we selected St. Louis for this workshop is because it’s part of the Route 66 story and it’s still chock full of amazing signage still intact from the 1950s and 1960s! We’ll spend the first full day shooting photographs of these amazing signs throughout the city stopping every so often for passengers to swap from car-to-car with 3-4 stops along the way! By the end of the day you’ll have some amazing vintage sign photos and a swell new group of pals!

The second day will be totally focused on vector letter tracing/drawing basics using the photos we shot the day previously as your reference and our goal is to help you complete a set of 26 capital letters by the end of the day. On our third day together, we’ll switch gears and spend the day importing your letters, spacing, kerning and generating your first font!

While we’re together throughout the weekend, we’ll have a host of special surprise evening events that we can’t wait to share with you and you’ll leave with a strong foundation how to develop your own typefaces and how to expand on the font you’ve created at this workshop to use as you wish!

18–23 November 2017: Khatt Arabic Type Design Workshops 2017

0
0

The Khatt Foundation will host workshops at Tashkeel in Dubai this November. This is a unique chance to get started with Arabic type design or perfect your Arabic Glyphs skills!

Workshop: Arabic Type Design for Beginners

  • When?

    18–23 November 2017
    10 a.m. – 6 p.m.

  • Who?

    Khajag Apelian
    Huda Smitshuijzen AbiFarès
    Georg Seifert

  • Where?

    Tashkeel
    Nad Al Sheba 1
    Dubai, UAE

  • How much?

    AED 6,000.00

  • For whom?

    Max. 20 Students

  • Prerequisites

    Some experience in Adobe Illustrator and with a Mac; bring your own MacBook (macOS 10.9+).

  • Links

    Arabic Type Design for Beginners

The workshop will consist of historical presentations and practical exercises on Arabic lettering and typeface design. It will introduce the participants to the basics of the Glyphs font authoring software. It will teach participant how to translate lettering into digital outlines, and how to develop and generate a basic functioning Arabic font.

Instruction will for this level include the following:
—Historical presentation on Arabic calligraphy and typography
—Lettering and their translation to digital outlines
—The basics of the Glyphs authoring software
—The creation of basic Arabic character set
—The production of functioning Arabic font.

Workshop: Advanced Arabic Type Design

  • When?

    18–23 November 2017
    10 a.m. – 6 p.m.

  • Who?

    Khajag Apelian
    Huda Smitshuijzen AbiFarès
    Georg Seifert

  • Where?

    Tashkeel
    Nad Al Sheba 1
    Dubai, UAE

  • How much?

    AED 6,000.00

  • For whom?

    Max. 19 participants, who have taken previous Khatt Foundation Type Design workshops at Tashkeel, or designers that have experience in type design and would like to continue on developing their skills and learning new type design authoring tools.

  • Prerequisites

    Some experience in type design software, experience with a Mac; bring your own MacBook (macOS 10.9+).

  • Links

    Advanced Arabic Type Design

The workshop will teach the participants some advanced tools on further expanding the character set and fine tuning the font file into a more comprehensive and professional font.

Instruction will include for the advanced level the following:
—Localized alternates (farsi, urdu)
—Proportional/stylistic variations (ie. condensed, italics…etc).
—Contextual alternates/special ligatures
—Multiple Master + Alternative Interpolations
—Class kerning
And more…

23–27 August 2017: Glyphs at TypeCon 2017

0
0

TypeCon is back in Boston! Don’t miss out on the workshops by accomplished designer and digital punchcutter Lisa Schultz (Schriftlabor) and Glyphs developer Georg Seifert.

TrueType Hinting in Glyphs: Optimize Your TTFs for the Screen

TrueType hinting, the final frontier: learn how to set up TTF Autohint parameters for your font project, and how to add TrueType instructions to your outlines. It is easier than you think to make your fonts look great in Windows. Glyphs coder Georg Seifert will be present. Bring your own font project, or use the sample font provided.

Open Feedback Session: Q&A with the Developer of Glyphs

Feature request? Specific technical problem? Confidential bug report? In this personal and exclusive feedback and Q&A session with the developer of Glyphs, Georg Seifert, you can discuss problems you encountered, or ideas you have for improving the software. Either Georg will show a solution for your problem, fix that annoying bug, or add that much-coveted feature, perhaps even right away. Book early, seating is limited.

12–13 August 2017: Type Design for Non-Type Designers

0
0

Get a crash course in designing type from Matteo Bologna, Creative Director of award-winning studio Mucca Design (and mastermind behind some of the most drool-worthy typography we’ve ever seen). The workshop will introduce you to the basic skills necessary for the wild journey into the super fun world of type design.

Type Design for Non-Type Designers

In this class you will learn the basics of designing and generating a typeface with Adobe Illustrator and the font-design software Glyphs (Mac only). Go beyond choosing the same fonts from the type menu to creating your own typefaces.

Students will learn the basics of drawing a font, generate the font, and use it in InDesign. At the end of the weekend students will have a respectable start of a typeface design.

23–27 August 2017: Raabs Symposion

0
0

Glyphs is proud to be amongst the sponsors of this year’s edition of the triennial Raabs Symposion at the Czech-Austrian border. Team member Rainer Erich Scheichelbauer will be present, and ready to answer any questions you have about the software.

Glyphs First Aid in Permanence

Bring it on. As long as they are about Glyphs, Rainer Erich Scheichelbauer will answer your most difficult questions, and solve your worst problems.

Viewing all 502 articles
Browse latest View live




Latest Images