More Unicode Patterns

Creating is the most intense excitement one can come to know.

Anni Albers, On Designing

I recently wrote a post — that was shared here on CSS-Tricks — where I looked at ways to use Unicode characters to create interesting (and random) patterns. Since then, I’ve continued to seek new characters to build new patterns. I even borrowed a book about Unicode from a local library.

(That’s a really thick book, by the way.)

It’s all up to your imagination to see the possible patterns a Unicode character can make. Although not all characters are good as patterns, the process is a good exercise for me.

And, aside from Unicode itself, the methods to build the patterns may not be so obvious. It usually takes a lot of inspiration and trial and error to come up with new ones.

More tiling

There are actually many ways to do tiling. Here’s one of my favorite tile patterns, which can be easily achieved using CSS grid:

A Series Of Squares That Vary In Size From Small To Large And Are Arranged In A Masonry Pattern.
.grid {
  /* using `dense` to fill gaps automatically. */
  grid-auto-flow: dense;

.cell {
  /* using `span` to change cell size */
  grid-column-end: span <num>;
  grid-row-end: span <num>;

Grid Invaders by Miriam Suzanne is a good example of this technique.

Now, what I’m trying to do is put some Unicode characters into this grid. And most importantly, update the font-size value according to the span of its cell.

A Series Of Red And Orange Chinese Unicode Characters Arranged In The Grid Pattern Of The Previous Image.
Pattern using characters 2f3c through 2f9f

I only tested with Chrome on Mac. Some of the examples may look awful on other browsers/platforms.

.cell {
  /* ... */
  --n: <random-span>;
  grid-column-end: span var(--n);
  grid-row-end: span var(--n);

.cell:after {
  /* ... */
  font-size: calc(var(--n) * 2vmin);

It’s a bit like the Tag Cloud effect, but with CSS. Lots of patterns can be made this way.

A Series Of Orange And Red 2686 And 2689 Unicode Characters Arranged In The Same Grid Pattern As The Other Examples.
Pattern using characters 2686 through 2689
Unicode Characters 21B0, 21B1, 21B2 And 21B4 Arranged In The Same Grid Pattern As The Other Examples. The Effect Is Like A Series Of Arrows Pointed In Different Directions.
Pattern using charaters 21b0, 21b1, 21b2 and 21b4

The span of the columns and rows don’t always have to be the same value. We can make small modifications by changing how many rows each cell spans:

The Grid Layout With Taller Columns Now That Each Cell Spans More Rows.
.cell {
  /* only change the row span */
  grid-row-end: span <num>;

Since the font-size property scales up/down in both directions (vertically and horizontally), the scaleY() in the transform property will be used instead.

Red And Blue Diamond-Shaped Unicode Characters Squeezed Into The Taller, Thinner Columns Of The Grid Layout.
Pattern using characters 25c6 through 25c8
:after {
  /* ... */
  transform: scaleY(calc(var(--span) * 1.4));

And here’s another one, made by rotating the inner container of the grid to some degree.

Red And Blue Triangles Pointed Diagonally In The Grid Layout.

The triangles also can be drawn with clip-path and will be more responsive, but it’s nice to do something in a different way.

More modifications to the layout:

The Grid Layout With Skewed Cells So That They Form Repeating Parallelograms Instead Of Rectangles.
.column-odd {
  transform: skewY(40deg);

.column-even {
  transform: skewY(-40deg);

Now follow these transformations for each column.

Plus Sign Unicode Characters In Green, Red, Yellow And Gray That Follow The Parallelogram Pattern Of The Updated Grid, Forming A Crochet-Like Effect.
Pattern using characters 1690 through 1694


Many Unicode pairs share some kind of shape with different angles. For example, parentheses, brackets, and arrows with different that go in different directions. We can use this concept to combine the shapes and generate repeatable patterns.

This pattern uses less-than and greater-than signs for the base:

Wavy Pattern Using &Lt;Code&Gt;&Lt;&Lt;/Code&Gt; And &Lt;Code&Gt;&Gt;&Lt;/Code&Gt;
:nth-child(odd):after {
  content: '<';

:nth-child(even):after {
  content: '>';

Here we go with parentheses:

More Unicode Patterns
A wavy pattern using ( and )
:nth-child(odd):after {
  content: '(';

:nth-child(even):after {
  content: ')';

These are characters we use everyday. However, they give us a fresh look and feeling when they are arranged in a new way.

There’s another pair of characters, , and . Placing them in the grid and scaling to a proper value connect them together into a seamless pattern:

More Unicode Patterns

It’s like weaving with characters! We can even take it up a notch by rotating things:

More Unicode Patterns
Pattern using 169b and 169c


Last week, I joined a CodePen Challenge that challenged the group to make a design out of the sub and sup elements. As I experimented with them, I noticed that the two tags scaled down automatically when nested.

More Unicode Patterns

So, I tried to put them around a circle:

More Unicode Patterns
.first-level {
  /* Slice the circle into many segments. */
  transform: rotate(
    calc(360deg / var(--slice) * var(--n))

Suddenly, I realized this method can be used to generate background patterns, too. The results are pretty nice.

The Unicode Characters For Less-Than And Greater-Than Signs Repeated In A Circle That Starts Large Around The Edge And Narrows In, Like The Characters Are Flushing Down A Drain.
Pattern using