Nyquist Art + Logic

Amazing Spider-Man

2026-03-01T12:13:00.001-07:00

My Blender Grease Pencil illustration "Amazing Spider-Man" made the CGCookie 2025 reel and it was the only Grease Pencil illustration to make the reel!

What started as a doodle while I was on the phone, turned into a finished illustration. Using the Grease Pencil can be challenging and rewarding. I learned quite a bit from Grease Pencil guru Paul Caggegi’s excellent courses on the topic.

The style of the illustration attempts to reflect the Silver Age/Bronze Age of comic books. I even worked with the palette of colors comics used at that time.

CGCookie is the premier Blender training site, so it was quite an honor. Check out the reel here: https://lnkd.in/eVftUGEb

Does This Compile?

2026-02-16T07:20:00.001-07:00

When I was teaching at Sun Microsystems (2000-2002), I created the example below for my Java classes. Around day 3 or 4 I would start writing it on the whiteboard piece-by-piece and asking "does this compile?" Then I'd proceed to walk the students through why it worked. The point was to show how identifiers are resolved, and then show things that would conflict and why.

What’s changed is I added a little generic static method to add to the fun (they weren’t in the language when I taught).

class x {
    static x x = new x();
    x() { }
    x x(x x) {
        return x;
    }
    static <x> x x(x x) {
        return x;
    }
    public static void main(String[] args) {
        x x = new x();
        System.out.println(x.<String>x("x"));
    }
}

This code compiles and, when run, prints:

Bits of Blender #79 - Stroke Material Add-On

2025-08-26T07:21:00.005-06:00

In this Bit I show you my new Stroke Material Display add-on/extension. If you work with the Grease Pencil, you may find this very helpful.

Stroke Material Display on Blender Extensions

The superhero in the video is Safeguard, one of the heroes from MOST: The Adventures of Ion and Echo! and used courtesy of MOST Comics, LLC.

MOST is a free web comic book done in the classic style of the Silver/Bronze age of comic book. It was done by Richard when he was in college.

Bits of Blender #78 - Mirror and Bisect

2025-08-02T07:30:00.004-06:00

I watched a great video by Lino Thomas at the Blender 2022 conference. Afterwards I felt like I had to explore further mirroring and bisecting (and flipping) to create complexity using the mirror modifier.

One hour of greeble - Live workshop at the Blender Conference 2022

Bits of Blender #77 - Distribute Strokes Extension

2025-07-07T18:39:00.008-06:00

I created a simple extension/add-on to distribute Grease Pencil strokes.

I show you how the add-on works, how you can get it, and where you can find the code if you have interest in seeing how extensions work.

Bits of Blender #76 - Joining Strokes in 4.4 vs 4.2

2025-07-05T18:38:00.002-06:00

The way you join Grease Pencil strokes has changed. In this video I show you how it was in 4.2 LTS and compare it to 4.4.

Bits of Blender #75 - Run multiple instances of Blender on a Mac

2025-06-30T18:37:00.001-06:00

How do you run multiple instances of the SAME version of Blender on a Mac?

It is a quick tip, in a nutshell... Run this in the Terminal: open -n -a Blender

Bits of Blender #74 - Bézier Curves, Part 2

2025-06-28T08:34:00.003-06:00

This Bit builds on Bit #73, going further into using Blender’s beautiful Bézier curve tools.

Bits of Blender #73 - Bézier Curves, Part 1

2025-06-28T08:32:00.006-06:00

Blender has powerful Bézier curve tools that are a bit different than what you may be used to in other vector programs. This episode introduces you to how Blender handles Bézier handles.

It’s a little different from other vector programs like Adobe Illustrator and Affinity Designer, in fact I think it is better being able to easily see the handle types.

Bits of Blender #72 - A REAL 3-button Mouse

2025-06-23T11:48:00.004-06:00

With Blender I use a trackpad, Wacom, and a Huion tablet monitor, but I’ve always wanted a good ol’ fashioned 3-button mouse, and I finally found one! This is not a paid endorsement, just news of a cool mouse I found to use with Blender 🤠 You can get the Elecom mouse here: https://www.amazon.com/ELECOM-Japan-Brand-BlueLED-Symmetrical-M-CAD01UBBK/dp/B07W5CXW6M

New Logo and New Bit!

2025-06-20T09:56:00.004-06:00

Blender can be a challenge to learn at first, but its key commands are instantly addictive. I started using Adobe Illustrator with version 1.1 in 1987, but when I discovered Blender 2.37a in 2005, its shortcuts like G, S, R, X, and E quickly overtook 18 years of Illustrator muscle memory. I even caught myself trying to use them in the venerable vector tool!

So for the new Bits of Blender logo (my series of quick tips and tutorials for the Blender community), I turned to Blender itself. I began with thumbnails using the Grease Pencil. For the final artwork, I switched to Blender’s Curve object using version 4.4.

The Curve edit mode’s Pen tool, introduced a few years ago, should feel familiar to anyone who’s used vector drawing tools like Illustrator. The circular design features text wrapped around the outside of a bezier circle and the inside of another. Getting the text to align inside the circle had me stuck for a moment. I realized it was a matter of scaling the circle on the negative Y axis, which is not something you'd do in Illustrator!

I created a one-minute Bit tutorial to share the solution. Let me know what you think of the new logo, and/or share your own tips for working with Blender’s Curve tools!

I did thumbnails using the Grease Pencil. Here's an example of the one I picked to move forward with.

It is always good to design in black and white first. This is just a step from being final, I decided I preferred the text in the circle to be all caps.

Final art, animated.

The logo mentions the year we started, has two sillouettes of the Blender Monkey object to represent me and Richard. The "o" is a nod to the 3D cursor pioneered by Blender. And of course it has a 0 and 1 to represent the computer "bit", which we use as a play on words for our series (a "bit" as in "a brief performance").

A Tour of Blender (and Bits of Blender turns 17)

2025-06-09T08:00:00.024-06:00

Seventeen years ago, Bits of Blender launched on YouTube, back when videos were 320x240 and could not exceed 10 minutes. That was long enough for me and my 9-year-old son, Richard, to share quick Blender tips.

Blender 2.4x had a reputation for being challenging, but we thought a 9-year-old using it might inspire others to get over that initial hump in learning it.

For our anniversary, we’re dropping a special Bit... a 45-minute guided tour of Blender 4.4 as we build an animation from scratch, visiting each of the workspaces.

Watch now and share your comments on the video or memories of our old Bits! #blender #blender3d

Side note, this 45-minute episode about Blender was also edited in Blender with its Video Sequence Editor (VSE)!

Distribute Grease Pencil Strokes

2025-05-31T16:15:00.016-06:00

I’m happy to share my first Blender Add-On! I couldn’t find a tool to evenly distribute grease pencil strokes in Blender or existing Add-Ons, so I built one myself. It’s simple but gets the job done! Check it out and let me know your thoughts.

#blender #blender3d

https://github.com/johnrnyquist/distribute_grease_pencil_strokes

Handling Gesture Recognizers and TouchesBegan in SpriteKit

2025-03-04T13:07:00.003-07:00

Are you working on a SpriteKit game and trying to use both gesture recognizers and touchesBegan? I spent more time than I expected figuring this out. After asking AIs and not getting clear answers, I ended up checking the friendly manual myself.

Thought I’d write a quick blog post about it—maybe it’ll help someone else searching for this later.

The issue is that touchesBegan happens before the gesture recognizer. There’s an easy fix: set delaysTouchesBegan to true. Here’s an example:

override func didMove(to view: SKView) {
        let panGestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handlePanFrom))
        panGestureRecognizer.delegate = self
        panGestureRecognizer.delaysTouchesBegan = true
        self.view!.addGestureRecognizer(panGestureRecognizer)
}

Why was it tricky to find? I think it’s because SpriteKit doesn’t get much attention these days, so there’s not a lot of discussion about it online. Hopefully this saves you some time!

Swashteroids 2.6

2025-02-18T07:06:00.003-07:00

Version 2.6 has a lot of new features:

New Phasing power-up! Temporarily nothing can touch you!
New Xray power-up! See what treasures are in which asteroids!
New button to trigger shields, enable them in your own time (or not).
Improved the TRAINING section.
Now using Apple SpriteKit’s physics engine to detect collisions.

Since my last Swashteroids blog post in Dec 2023, I've released many updates!

Version 2.6
Version 2.5
Version 2.4.2
Version 2.4.1
Version 2.4
Version 2.3
Version 2.2
Version 2.1.2
Version 2.1.1
Version 2.1
Version 2.0.1

Here's a video showing all the new power-ups (note: this is level 5)

Swasteroids 2.0

2023-12-16T07:53:00.003-07:00

I’ve released Swashteroids 2.0 to the App Store! A fun retro open-source game built on my open-source ECS framework Swash.

All new user-interface and art. Play with or without buttons! Plasma torpedoes and hyperspace are now both power-ups, and they're moving! Game play mechanics have been tweaked, ie asteroids' base speeds increase per level. The game starts easier as well so you can warm up.

https://apps.apple.com/us/app/swashteroids/id6472061502

2023-11-20T06:29:00.003-07:00

I’ve released Swashteroids to the App Store! A fun retro open-source game built on my open-source ECS framework Swash.

https://apps.apple.com/us/app/swashteroids/id6472061502

2023-11-17T06:26:00.001-07:00

Version 2.0 of my Near Mint iOS app is now live! This release has many new features and other improvements. This is an app that helps you organize your comic book collection. It is fast and native since 2017! 🤠

#comicbooks #ios

Swift Arrays to Dictionaries with indices

2022-04-14T19:40:00.001-06:00

The extension below is to facilitate the creation of dictionaries from arrays. In this case, the dictionary has the array element as the key and the index of that element as the value.

Since I was only working with arrays that held unique values I added a guard statement to enforce that. If you remove it, then your the last duplicated element would have the index as its value.

extension Array where Element: Hashable {

func toDictionary() -> [Element: Int] {

guard Set(self).count == self.count else {

fatalError("\(#function) requires arrays with unique values!")

}

return self

.enumerated()

.reduce(into: [Element: Int]()) { dict, tup in

dict[tup.1] = tup.0

}

["hello", "world"].toDictionary() // ["world": 1, "hello": 0]

100 Days of Swift

2019-06-01T14:03:00.001-06:00

3. For a tougher challenge, take the image generation code out of cellForRowAt: generate all images when the app first launches, and use those smaller versions instead. For bonus points, combine the getDocumentsDirectory() method I introduced in project 10 so that you save the resulting cache to make sure it never happens again.

As a reminder, here’s the code for getDocumentsDirectory():

func getDocumentsDirectory() -> URL {

    let paths = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)

    return paths[0]

}

The above is from Day 98 of Paul Hudson's excellent course: 100 Days of Swift. It is Challenge #3 and there is even a "bonus" challenge inside the challenge! In approaching the solution--before coding--I wrote down my thoughts and then gathered snippets of code that I thought would help. My notes are below. I thought it might be helpful for others to share them without giving away the solution.

First, I jotted down the four main things I was concerned with:

Read big images from bundle, see project 1.
Render a image into a rect using CoreGraphics like in project 30.
Read the thumbnails in like project 10.
If a thumbnail does not exist then create it. Also like in project 10.

Next, I gathered the corresponding snippets of the code:

From project 1:

DispatchQueue.global(qos: .userInitiated).async { [weak self] in

    let fm = FileManager.default

    let path = Bundle.main.resourcePath!

    let items = try! fm.contentsOfDirectory(atPath: path)

    let pictureNames = items

        .filter { $0.hasPrefix("nssl") }

        .sorted { $0 < $1 }

    self?.storms = pictureNames.map {

        Storm(name: $0, imageName: $0) }

    DispatchQueue.main.async { [weak self] in

        self?.collectionView.reloadData()

}

}

From project 30:

        let path = Bundle.main.path(forResource: imageRootName, ofType: nil)!

        let original = UIImage(contentsOfFile: path)!

        let renderRect = CGRect(origin: .zero, size: CGSize(width: 90, height: 90))

        let renderer = UIGraphicsImageRenderer(size: renderRect.size)

        let rounded = renderer.image { ctx in

            ctx.cgContext.addEllipse(in: renderRect)

            ctx.cgContext.clip()

            original.draw(in: renderRect)

}

From project 10:

Write:

        let imageName = UUID().uuidString

        let imagePath = getDocumentsDirectory().appendingPathComponent(imageName)

        if let jpegData = image.jpegData(compressionQuality: 0.8) {

            try? jpegData.write(to: imagePath)

}

Read:

        let path = getDocumentsDirectory().appendingPathComponent(person.imageName)

        cell.imageView.image = UIImage(contentsOfFile: path.path)

The Ash Entity Framework

2014-12-31T14:39:00.003-07:00

I’ve been doing object-oriented programming for over 20 years. I’ve worked with many languages in that time. One can improve their ability to abstract the more they work with different languages. A more challenging exercise is to change your programming paradigm.

Lately, the paradigm I’ve been experimenting with is entity component systems (ECS). ECS are touted for game programming. A common scenario in games is for things in the game to changes powers and abilities. To solve this issue in the past, I’ve relied heavily on composition over inheritance. In ECS, that idea is taken to the extreme.

The objects (entities) are made up of components (that are mostly value objects), the logic resides in the systems that operate on the entities. After reading an excellent post by Richard Lord, I decided to give his ECS micro framework a try, it’s call Ash.

The Ash Entity Framework

The Ash Entity Framework uses entity, components, systems, and nodes. Ash facilities the work of mapping the systems to the components they work on. Let me define these:

Components are (mostly) simple value objects. They contain little or no behavior.
Entities hold components. Entities only care about components. By changing what components an entity has affects which systems affect the entity. This changing of entity composition is important as it impacts node creation as well as which systems execute on it. Entity names must be unique!
Systems operate on lists of nodes. Systems only care about nodes. Systems contain the logic.
Nodes are combinations of one or more components. Node classes are defined and at runtime, an entity that has components matching the definition gets a node created by the Ash engine. Ash also removes and destroys nodes when they are no longer applicable to the entity composition. Node lists use signals--not events--for adding and removing.

The Engine is part of the framework. It knows about entities and systems, both of which you add to the engine. It in turn watches entities and--as they change--adds and removes the components to node collections used by systems. The engine creates the node collections and passes them to the appropriate systems.

ABGC On Sale

2014-02-12T11:44:00.003-07:00

My course A Blender Game Character is on sale at CartoonSmart thru Saturday, $25 (usually $39) #b3d

Bits of Blender #67 - Text Boxes

2013-12-29T12:12:00.000-07:00

Did you know you could use text boxes/frames in Blender? John and Richard show you how in this Bit.

Bits of Blender #66 - Object Fonts

2013-12-22T11:44:00.001-07:00

Do you know how to create your own fonts using Blender objects? This Bit shows you how.

Bits of Blender #65 - Typography

2013-12-16T12:48:00.004-07:00

It's the Bits of Blender Christmas edition! In it we show you how to do some typographic tricks using nodes.