The frame consists of two beams stabilized by two uprights. The beams and uprights are 3" by 2" and laminated from two layers of maple for additional strength. The joints between them are dowelled.

The baseplate and plinth are 12" by 15" and made of 18mm baltic birch plywood. The baseplate is screwed to the bottom of the frame and supports front and rear walls made of 1" thick maple. The plinth is grooved so it registers with the walls but is otherwise free-floating. It rests directly upon the bottom beam so the frame absorbs all the force from the screw. The walls are only there to keep the plinth in place.

The press has three top plates of various sizes, to accommodate paper up to 5x7", 8x10" or 11x14". When pressing larger paper, the smaller top plates can be stacked on top of the larger ones to help distribute force. (As shown, the two smaller plates are stacked on top of the paper being pressed, and the large plate is below.)

All surfaces are finished with Osmo Polyx hard wax oil in the gloss sheen.

I would be happy to make more presses like this, so if you're a bookbinder please contact me for details.

• Design refresh! (It's largely the same as before, but tightened up a bit.)
• New channels for Guitars and Woodwork that make examples of my work more prominent.
• A new Services page.

In addition to these changes, I've decided to require a (free) subscription for most of my longer form writing, like tutorials. You can read why here. If you received this post by email, you're already subscribed.

• Reusable bag drying racks
• Fretting with the Fractal Fret Press
• Small manual screwdriver
• T-style guitars with new custom necks
• Reusable bag drying rack (again)
• Using a cabinet installation jack as a drill press table lift

Build One (Green)

Body: Swamp ash
Finish: Lee Valley aniline dye in forest green, Osmo Polyx (satin) and Walrus Oil furniture wax.
Pickguard: Curly maple finished with Osmo Polyx (satin)
Neck: Riftsawn walnut with a quartersawn white oak fretboard and walnut face markers, finished with Osmo Polyx. The fretboard is pore-filled with CA glue for a hard finish, similar to a lacquered maple fretboard.
Pickups: Fender American Vintage ‘52 Telecaster
Bridge: Wilkinson by Gotoh WT3
Tuners: Gotoh SD381-MG-T 6-in-line locking
Fretboard radius: 16”
Weight: 7lbs, 9oz.

Build Two (Blue)

Body: Maple
Finish: Lee Valley aniline dye in peacock blue, Osmo Polyx (satin) and Walrus Oil furniture wax.
Neck: Riftsawn mahogany with a canarywood fretboard and padauk face markers, finished with Osmo Polyx.
Pickups: StewMac “The Standard Telecaster”
Bridge: Gotoh GTC201
Tuners: Gotoh SD381-MG-T 6-in-line locking
Fretboard radius: 16”
Weight: 9lbs, 6oz.

I've made a batch of these racks for my online store. They're available in two sizes. The smaller rack is good for small and medium size bags, and for Swedish dish cloths. The larger rack will do everything the smaller one does and handle larger bags up to 30cm (12") deep.

The tealight tray and bud vase/organizer shown below are currently available in my new online store.

• Tealight Tray
• Bud Vase/Organizer
• Neck carving — the best part of the guitarmaking process
• Repairing small dents with steam
• Thinning a guitar headstock
• A Firebird-esque top profile on a new guitar body prototype
• Progress on a new guitar body prototype
• Arm carve on a new guitar body prototype
• Belly carve on a new guitar body prototype

I was careful to match all dimensions to the originals so the panels would be as close to a perfect reproduction as possible. The mounting holes and counterbores seem unnecessarily large at first, but the original manufacturing tolerances were probably a bit loose and 48 years of handling certainly hasn't helped. Larger holes allow a bit of play to better align the side panels to the control panel.

The Instagram reel shows how much this simple upgrade improved the tuner's appearance:

• New purpleheart bud vases for sale at J2 Gallery in Gananoque
• Trying out a planar arm carve and lower horn slope on a guitar body prototype
• Fun geological finds in the table saw after cutting acrylic
• Headstock veneer sandwiches
• A mildly suggestive bookmatched walnut panel
• Solid walnut side panel upgrade for a 1978 Sony AM/FM tuner
• Partial depth fretboard binding

My goal in writing this is not to give a detailed account of my time at Blackwood ("on day 1, we chose our woods and I almost started a fire in the drum sander" – true story) but to give you an idea of what you might expect from the course.

Blackwood is owned and operated by Ted Brown, a luthier who studied with Sergei DeJonge and Michel Pellerin. Ted also studied cabinetmaking with James Krenov at College of the Redwoods and founded Rosewood Studio. In my experience, Ted is direct and fair, the sort of no-bullshit teacher you should want if you're serious about learning something. He isn't going to do your work for you but he will help you when you need it.

You have your choice of several guitar designs and woods, which you'll choose on the first day. A basic back and sides set is included with the course, or you can upgrade to fancier woods at an additional cost. I chose a twelve fret parlor body style with Indian rosewood back and sides and a lutz spruce top. (I didn't upgrade because I'm cheap and the basic woods were of high quality.) All other materials and tools are provided. Each bench is equipped with a set of basic hand tools. There is also a shared set of hand tools, a machine shop, and more clamps than you've probably ever seen in one place. (And yet, somehow, we still could have used more clamps.)

The course moves very fast. It has to, because getting several students from zero to a completed guitar in five weeks is a tall order. I'm used to working alone and at my own pace in a private workshop, so it took me a few days to get used to working in a shared space and on someone else's schedule. I fell behind early in the course, and while I was never more than a half day behind the rest of the class, it took me about three weeks before I really felt like I had caught up. Be prepared to work hard and at a high level of focus every day, and expect to work overtime on evenings and Saturday mornings.

Ted demonstrates processes at a pace that is intended to keep the class moving forward. That means that you may get a demo hours or days before you'll be ready to carry out the process. The provided notes serve as a good reminder of the order of operations for each process but are often short on details. You need to take your own notes, and take photos and videos of all the demos and setups so you can refer to them later.

Things will go wrong. Wood will be wood. It will not always behave the way you expect. You will make mistakes. You're building a guitar, but you're also going to get some repair experience along the way. Your first guitar was never going to be perfect, so treat problems as learning opportunities and try to recover as gracefully as you can.

There's no guarantee that you'll actually finish your guitar. I gather that most people do, more or less, but it depends on you putting in the work. Everyone in my class finished, and we even had some time to dial in our setups, but we also had the benefit of a smaller than usual class size. My guitar could still use some more finish work on the back and sides, but that's no problem. Ted teaches French polishing in the course, which makes it easy to touch up the finish in the future. For now, I'm enjoying my guitar and not worried about the flaws.

If you're thinking about taking an acoustic guitar building course, I recommend Blackwood. It isn't easy, but if you put in the work you'll be rewarded with a great guitar and a solid grasp of the craft.

• Progress check for a new batch of guitar necks
• Walnut speaker stands spotted in the wild
• Smoothing a guitar body blank by hand
• My bud vases are available at J2 Gallery in Gananoque

J2 is located at 33 King St. East, right across from Gananoque Town Hall.

Excuse my language....but those look f**king dope! – Satisfied Customer

I recently received a commission to build a pair of stands for a set of floor speakers. The customer wanted to raise the speakers roughly 9" and tilt them back to improve projection. The speakers have a faux-walnut veneer so we decided to use solid walnut for the stands, so they would be reasonably close in colour.

I started by building a parametric CAD model of the stands. I normally don't model my projects. I prefer to sketch things out in pencil on graph paper, and I generally only measure parts whose dimensions are critical to the success of the project. Everything else is marked and cut in reference to those critical parts. The benefit of having a model doesn't always justify the effort involved in creating it. However, I felt that I needed a model for this project, for a few reasons:

• The stands would tilt back and I didn't know what the ideal angle would be. Changing the angle would affect other dimensions, particularly the length of the joint between the leg and speaker support.
• I wanted to provide the customer with a simple rendering and to be able to respond quickly if they wanted changes.

Once the customer approved the rendering, I went shopping for lumber, milled it to the rough dimensions required by the designs, and stickered it for a few weeks to make sure it would be stable.

Each stand would have two leg assemblies, each consisting of three parts: the base, the leg and the speaker support. The leg assemblies had to be identical. Any deviation would prevent the stands from sitting properly on the floor, or prevent the speakers from sitting properly on the stands, or both. Either of these conditions could introduce vibration that would take away from the music. The best way to achieve the necessary consistency across all the parts would be to rout them to a template, so I made a templates for the three parts of the leg assembly from 12mm birch plywood. I traced the templates onto the lumber, cut the parts close to the lines on the bandsaw, and routed the parts to the templates. I also cut the cross brace for each stand on the table saw.

The parts would be assembled using three 1/4" dowels per joint. I marked precise center lines on the legs, continued the lines onto the bases and speaker supports, and used them to align my drilling jig. After drilling for the joints between the leg and base, and the leg and speaker support, I drilled another set of holes on the inside of each leg to attach the leg assembles to the cross brace. A dry fit of all the parts showed that dowel joinery could not guarantee that both speaker supports would end up with precisely the same tilt angle. It would be very easy for the leg assemblies to end up slightly out of plane with one another, so I needed a way to keep them aligned during glue-up. My solution was to use the dowel holes on the inside of each leg to keep the legs in the same position – leaving a bit of space between them so they wouldn't be glued together accidentally – and to clamp the bases and speaker supports between scraps of plywood to keep them coplanar.

Next, I sanded the leg assemblies and cross braces, and routed roundovers around all the outside edges except where the stands would make contact with the speakers and the floor. I used a router to establish a consistent 1/8" radius for the roundovers but sanded them out by hand for a less mechanical look. The last step of assembly involved glueing the legs to the cross braces. I clamped them together lightly and put a five pound weight on top of each assembly to keep the legs planted to the bench while the glue dried. The result is a pair of stands that sit perfectly flat.

I finished the stands with Osmo Polyx hard wax oil in a satin sheen, which is my go-to finish for most things, but especially for walnut.

Overall, I'm very happy with how this project turned out. My customer's feedback has been overwhelmingly positive, not only with regard to the stands' appearance and basic functionality, but also with regard to the improvement they've made to how his speakers sound. That wasn't something we could plan for in advance, but decoupling the speakers from the floor and tilting them towards the listener should make a difference.

• Gluing up a guitar body blank with Equipressure clamps
• Creating templates for a set of speaker stands
• Slotting a guitar fingerboard with a pull saw and miter box
• Psychedelic drill press
• Custom wood face dots for guitar fingerboards
• Routing guitar neck blanks for truss rods
• Creating a custom guitar headstock template
• Walnut speaker stands before applying finish
• Finishing walnut speaker stands

Panel glue-ups present two main challenges. First, you need the mating faces of each board to be straight and square to achieve a gap-free glue joint. This is accomplished with a jointer (power or hand plane) or maybe your table saw if you have a good enough blade. The second challenge is to keep the boards vertically aligned under clamping pressure. If you're working with long, thin boards, you may find that they're bowed enough to introduce alignment problems towards the middle of the panel. Even if all the boards are perfectly flat, they can drift out of alignment while the glue is wet. There are ways to solve these problems. You can pile on more clamps and cauls to force the boards into vertical alignment, but that can be difficult for large panels. You can clamp the boards and then try to hammer them into alignment, but that isn't a reliable method – nor is it graceful. You can also start with thicker boards and plane out the excess after the glue-up, if you have a big enough thickness planer, or enough skill and patience with a hand plane. Or you can try 4-way Equipressure clamps.

How Equipressure Clamps Work

The idea behind these clamps is simple. The two ends of a screw clamp are connected by bars that sit above and below the boards to be clamped. Tightening the screw applies horizontal pressure to join the boards while drawing the bars together to force the boards into vertical alignment. This is basically a streamlined version of the "more clamps and cauls" approach I mentioned above, and it works quite well in practice, at least for my purposes. A tool can be very effective in one context but fairly useless in another. When someone tells you that a tool works well, it's important to understand their test parameters so you can determine how they align with your own. Here are my parameters:

• I'm using these clamps to join guitar body blanks, which generally consist of two boards. I haven't tested these clamps on a large panel glue-up.
• I'm working with fairly thick hardwood stock. The minimum thickness is generally around 1-5/8" (41mm) and the boards are freshly surfaced on four sides. I'm using the clamps to keep the boards from slipping out of alignment more than to correct for distortion.

Your situation and needs may be different than mine, so take that into account when you decide whether or not to try this product.

Assembly and Use

Each clamp consists of two spring arms, one with a screw and the other with a fixed caul, and four brackets (two long and two short) that mount to bars that you provide. I milled my bars from rough 8/4 (2"or 50mm) maple to ensure that they would be as hard as, or harder than, most of the woods that I would be working with. You can make your bars as long as you need them to be. I chose 24" (around 600mm) for guitar body blanks and other small panels. The important dimensions are the width and height of the bars, which can't exceed 1-5/8" (41mm) and 2" (50mm) respectively, for the bars to fit through the spring arms. (Similar clamps are offered by several vendors and sizing may vary, so be sure to verify the clearance on your own spring arms before you make your bars.) Mount the brackets to the bars using the supplied hardware, using a long bracket on one end of each bar and a short one on the other. Finally, line the bars with packing tape to prevent glue from bonding to them.

To use the clamps, place one bar from each clamp on your bench with the brackets facing down. Arrange the boards for your panel across the bars, without glue. Place the other bar for each clamp across the top of the boards, with the brackets facing up. Slip the spring arms over the bars and into the grooves on the brackets, making sure to use the same grooves on the top and bottom bars. Unwind the screws all the way and move the spring arms to the innermost brackets that will accommodate your panel while allowing some leeway. Tighten the screws to make sure that everything aligns properly. Once you've completed a successful dry run, you can slide the boards out of the clamps to prepare for glue-up. Unfortunately, this is where it gets a bit tricky.

If you read reviews of these clamps, the common refrain is that they're awkward to set up. In my experience that's a valid complaint but there are ways to improve the situation. First, elevate the bottom row of bars from your bench by an inch or two. It's much easier to move the spring arms if they aren't resting on your bench under the weight of everything else. Second, cut some strips of thin wood slightly wider than the thickness of your panel and use them as spacers between the top and bottom bars so you can slide the boards in and out without resistance. Insert the spacers before you slide the boards in and remove them before you tighten the clamps. After you loosen the clamps, slide the spacers back in before you remove the panel. (If you can find a set of small bar clamps that can be reconfigured as spreaders to lift the top bar, I imagine that would work well in place of the spacers.)

With the boards out of the clamps, you can apply glue to the edges, reinsert the boards into the clamps, remove the spacers if you're using them, double check that everything is aligned and tighten the clamps. Wait 5-10 minutes for the glue squeeze out to thicken before you scrape off as much as you can reach – it's cleaner and more effective than cleaning it up with water. Leave the panel under clamping pressure according to the glue manufacturer's recommendations. The minimum time is usually between 30 and 60 minutes, but I like to do up my panel glue-ups at the end of the day and leave them clamped until the following morning.

The Results

After using these clamps I've only needed a few passes with a card scraper to clean off any remaining glue and get a perfect joint on my body blanks. The 4-way Equipressure clamps are a bit difficult to set up at first, but in my opinion the results are worth the effort.

How this will work:

• If you're reading this in an email, you'll see a list of links that point to my Instagram posts.
• If you're reading this on the web, the list of links will be replaced with embedded Instagram posts. (If that fails for some reason, the original list should still be visible.)
• If you use a browser or extension that blocks trackers, the embedded Instagram posts may not load but the links to the posts will still work.
• You'll see a login prompt when you view a post in a web browser while you aren't logged into Instagram. You can dismiss it with the X button.
• I won't include Instagram posts that just point back to posts on this blog.

Special thanks to Nessa for the "Reclaimed Wood" title! 🙂

Here's what I posted in January 2026:

• Fitting the neck for my second Telecaster build
• Installing string ferrules for my second Telecaster build
• An overview of my milling process for a guitar neck blank
• $2 amp cover
• An overview of my milling process for a guitar body blank
• Sheilding pickup cavities with copper foil tape for my second Telecaster build
• Pickups and bridge installed for my second Telecaster build
• Timelapse of the wiring for my second Telecaster build
• Everybody loves Richard Marx, right? Right?
• First sounds from my second Telecaster build
• Tuner installation for my second Telecaster build
• Using my ergonomic sanding block

The main difference between my version and Der-Garabedian's is that I've started with a larger blank and used more aggressive cutaways. I rough out the shape on the bandsaw, in part to reduce the amount of wood that I convert to dust, and in part to improve consistency. The fine shaping is done with spindle and edge sanders, and by hand sanding. The finish is Osmo Polyx in satin sheen to maintain a natural appearance.

Project date: December 2025

I'm generally averse to being on camera so you won't see much of me other than my hands. You also won't hear my voice very often. (That's no great loss.)

You will see whatever I'm working on today, or this week, so come follow along while I make things.

If you aren't reading this on your phone, you can use this QR code:

Most of these posts document a period from 2014 -2016 when I was doing audio-related programming work and writing about it. (I was still active for a few years afterwards but had stopped writing, which I regret. A lot happened in those years.) They're all out of date, but if you want to read them you can head over to the obsolete posts page.

When I build a design system for a website, I like to define a family of lighter and darker variants of each colour. In the past, I've done this by manually generating each variant in one of two ways:

• Using a design or colour management app to define each variant, then setting the hex/rgb values as css custom properties. This was slow to set up in the first place and made it difficult to adapt to changes later on. If I wanted to change the hue for a colour, I had to redefine all the variants and update all the custom properties.
• Defining the colours in code using hsl(). This made it easier to define variants by adjusting saturation and lightness without affecting the hue, and to change the hue later on without affecting saturation and lightness. The downside is that most of the colour values I receive from other people aren't defined in hsl to begin with. I still needed a colour picker to translate from other colour spaces.

Granted, you've been able to solve these issues for years by using sass, but I prefer standard css. This post will demonstrate how we can use the new color-mix function to generate colour variants in code without requiring other languages or tools. (At the time of writing, the Baseline status for color-mix() is "widely available," meaning that it has been implemented in all major browsers for at least 30 months and can generally be used without worrying about compatibility.)

The first step is to define a custom property for the accent colour.

:root {
  --color-accent: #6795cb;
}

I used this technique to generate the color variants for the Ghost theme on this site, using the --ghost-accent-color custom property instead of a fixed accent colour. This allows the accent colour to be configured in the Ghost theme settings.

:root {
  --color-accent: var(--ghost-accent-color);
}

Having defined the accent colour, we can define tinted variants of white and black. Adding a subtle tint to white and black can soften them and help them sit more comfortably with the accent colour.

I define custom properties for pure white and black that I incorporate into the color-mix() function and use anywhere else I want the pure variant. You might consider this to be an unnecessary step because pure white (#fff) and black (#000) are constant, but I prefer to have everything defined in one place.

Next, I use color-mix() to generate the tinted variants. This function requires a colour interpolation method consisting of the keyword in followed by a colour space. (I'm using the oklch colour space.) The second argument is the base colour – white or black, in this case. The third argument is the colour to be mixed into the base colour, and the mix percentage. The result is assigned to a new custom property.

Increasing the mix percentage will push the result towards the accent colour. Decreasing it will push it towards the base colour. The key here is subtlety – I normally use a 1% mix of the accent colour for white, and around 5-10% for black. The result should still pass for white or black if you look at it in isolation. If the mix is too strong, it will start to look like a highly diluted version of the accent colour.

:root {
  --color-accent: #6795cb;

  --color-white: #fff;

  --color-black: #000;
  
  --color-white-tinted: color-mix(
    in oklch, 
    var(--color-white), 
    var(--color-accent) 1%
  );
  
  --color-black-tinted: color-mix(
    in oklch, 
    var(--color-black), 
    var(--color-accent) 10%
  );
}

We can use the same technique to generate lighter and darker variants of the accent colour. I name these using levels from 050 to 950, e.g. --color-accent-350, similar to how font weight levels are specified. Level 500 is the pure accent colour. The levels below 500 increase the mix of white into the accent colour by 10% per level, making them progressively lighter. The levels above 500 increase the mix of black into the accent colour by 10% per level, making them progressively darker.

:root {
  --color-accent-050: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 90%
  );
  
  --color-accent-100: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 80%
  );
  
  --color-accent-150: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 70%
  );
  
  --color-accent-200: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 60%
  );
  
  --color-accent-250: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 50%
  );
  
  --color-accent-300: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 40%
  );
  
  --color-accent-350: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 30%
  );
  
  --color-accent-400: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 20%
  );
  
  --color-accent-450: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-white) 10%
  );
  
  --color-accent-500: var(--color-accent);
  
  --color-accent-550: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 10%
  );
  
  --color-accent-600: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 20%
  );
  
  --color-accent-650: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 30%
  );
  
  --color-accent-700: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 40%
  );
  
  --color-accent-750: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 50%
  );
  
  --color-accent-800: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 60%
  );
  
  --color-accent-850: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 70%
  );
  
  --color-accent-900: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 80%
  );
  
  --color-accent-950: color-mix(
    in oklch,
    var(--color-accent),
    var(--color-black) 90%
  );
}

If you're designing a larger system with many colours, you can repeat this for each one. Adjust the levels as necessary – perfect 10% increments may not be optimal for all colours.

I also use this technique to define variants of grey by mixing pure white into the tinted black, in 10% increments. Because we're mixing white into black, a higher mix percentage results in a lighter shade of grey.

:root {
  --color-gray-100: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 90%
  );
  
  --color-gray-200: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 80%
  );
  
  --color-gray-300: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 70%
  );
  
  --color-gray-400: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 60%
  );
  
  --color-gray-500: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 50%
  );
  
  --color-gray-600: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 40%
  );
  
  --color-gray-700: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 30%
  );
  
  --color-gray-800: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 20%
  );
  
  --color-gray-900: color-mix(
    in oklch,
    var(--color-black-tinted),
    var(--color-white) 10%
  );
}

Incorporate these variants into your design system however you like. For example, if you use --color-accent-500 (the pure accent colour) as the text colour for buttons, you might use a darker variant like --color-accent-600 for the hover and active states, and one of the greys for the disabled state.

button {
  color: var(--color-accent-500);
}

button:hover,
button:active {
  color: var(--color-accent-600);
}

button:disabled {
  color: var(--color-gray-500);
}

You might not use every one of these variants in your styles – I rarely do – but having them makes it easy to tweak the contrast between elements without altering the basic hue.

My last site was a static site built with Eleventy. It worked well enough (and cost nothing) but the publishing process, while not terribly onerous, still discouraged me from writing. Plus, any new post would have to be accompanied by a newsletter for anyone to notice it, which was just another thing to do.

This site is hosted with ghost and uses a custom theme that I can update easily on a whim. Or when something breaks. The big benefit of this setup is that I can type and press a _Publish_ button like a normal person, and other people (like you!) can subscribe and receive posts by email.

If you know me at all, it's likely that you know me as a software developer. Maybe as the guy who made the (now defunct) WebX0X drum machine back in 2015. I will occasionally write about software here, but my focus will be on woodworking and guitar making. Life's too short to stare at a screen all day, but I hope you'll find a few minutes to follow along with me.

Serialist is a live coding environment that uses serialist-grammar to generate MIDI messages. It requires a MIDI synthesizer (software or hardware) and does not generate any sound on its own.

View the project on Github. Just want to play? Visit serialist.irritantcreative.ca for the live demo.

A few weeks ago, I attended the International Conference on Live Coding at McMaster University in Hamilton, Ontario, Canada. The opening day workshops inspired me to design a new grammar and parser for the expression and transformation of rows in serial music composition. The resulting JavaScript library is called serialist-grammar and is available for free on Github and npm.

WebX0X has a new home at WebX0X.com. This update enables saving and sharing your beats.

WebX0X is a drum synthesizer and sequencer built using the Web Audio API. All sound generation is performed entirely in the browser without the use of samples.

Web Audio promises to bring high performance, low latency audio playback, processing and synthesis to the web. It's an intriguing prospect, since web browsers' audio capabilities have historically been limited to playback of pre-recorded files. Simple playback is important - it's easily the most common way that most people experience digital audio on the web - but without tools to generate and modify sound our creative options are restricted. Web Audio gives us those tools. WebX0X is a demonstration of some of its possibilities.

WebX0X takes its name from the classic drum machines made by Roland in the 1980s, most notably the TR-606, TR-707, TR-808 and TR-909. Like the 606 and 808, WebX0X synthesizes all its sounds using simple oscillators, noise generators, filters and envelope generators (the 909 used a mix of analog synthesis and digital samples, while the later 707 was entirely sample based), and has an integrated step sequencer to control patterns. WebX0X has 4 synthesizers, or ‘voices’. Unlike most classic analog drum machines, WebX0X uses the same algorithm for all voices. Each voice is tuned to resemble a different kind of drum by default (kick, snare, hihat and cowbell), but is also capable of a wide variety of other percussive sounds. This makes WebX0X very flexible.

Voice Architecture

Each voice has two signal paths, Tone and Noise that are combined at the Mix stage.

Tone

The Tone signal path consists of an oscillator, a filter and an amplifier. It can be used to give a sound ‘body’, like the ringing of a snare drum or the booming sound of a kick drum.

Oscillator

• Waveform: Selects the oscillator's waveform (triangle, sawtooth or square).
• Initial Pitch: Controls the oscillator's frequency at the onset of a sound.
• Final Pitch: Controls the oscillator's resting frequency.
• Pitch Decay: Controls the time it takes to transition from Initial Pitch to Final Pitch.
• Decay Curve: Selects the curve used by the pitch envelope generator (linear or exponential).

Filter

• Type: Selects the filter's algorithm (lowpass, highpass or bandpass).
• Initial Cutoff: Controls the filter's cutoff frequency at the onset of a sound.
• Final Cutoff: Controls the filter's resting cutoff frequency.
• Cutoff Decay: Controls the time it takes to transition from Initial Cutoff to Final Cutoff.
• Q: Controls the filter's resonance or bandwidth.
• Decay Curve: Selects the curve used by the filter cutoff envelope generator (linear or exponential).

Amp

• Level: Controls the tone's volume at the onset of a sound.
• Decay: Controls the time it takes to transition from Level to silence. This determines the perceived length of the tone.
• Decay Curve: Controls the curve used by the amp envelope generator (linear or exponential).

Noise

The Noise signal path consists of a noise generator, a filter and an amplifier. It can be used to give a sound ‘snap’, like the snares on a snare drum or the attack of a kick drum. It is also the main component of hihat and cymbal sounds.

Oscillator

• Color: Controls the quality of the noise source. Lower settings generate a more stable, ‘pure’ sound. Higher settings reduce fidelity.

Filter

• Similar to the Tone Filter section.

Amp

• Similar to the Tone Amp section.

Mix

• Level: Controls the voice's overall volume.
• Mute: Mutes or unmutes the voice.

Sequencer

Each voice has a 32 step sequencer. Each step represents one sixteenth note. Turn steps on or off by clicking them. The voice will play when the sequencer's playback position reaches a step that is on (highlighted).

All four sequencers are synced and controlled by the global transport buttons (Play/Pause and Stop) and tempo input.

Browser Compatibility

WebX0X supports recent versions of Chrome, Firefox and Safari on desktop (Chrome works best). It has also been tested in Mobile Safari (iOS 8).

I plan to add more components as I have time. The most obvious omissions from the current collection are horizontal and vertical faders, and a momentary switch or trigger pad, so I'll try to get to those soon.

Check out the source on Github.

Speaking of browser performance, Chrome currently handles projects with large or complex audio graphs better than Firefox or Safari, so I recommend running WebDrum under Chrome.

Check out the source on Github.

• WebSequence controls the order and execution of a series of events. Events are merely functions that execute arbitrary code at a given step in the sequence. Sequences may be modified by adding, replacing or removing events at any time, even during playback.
• WebSequenceTimer controls the timing pulse for one or more WebSequence objects. The time interval between pulses can be set in milliseconds or by specifying a tempo in beats per minute and a duration (e.g. 1/4 for a quarter note).

Check out the source on Github.

Check out the source on Github.

Check out the source on Github.

This tutorial assumes that you have basic working knowledge of the SuperCollider language. If you need help, the SuperCollider documentation is a good place to start.

Installing TWSuperColliderExtensions

Follow the TWSuperColliderExtensions installation instructions before continuing with this tutorial.

Introducing TWPitch, TWDuration and TWNote

TWPitch

TWPitch describes a pitch as a combination of a pitch class and octave. The pitch class and octave may be provided or inferred from a MIDI note number:

(
    var pitch1 = TWPitch.newPitch(pitchClass: 9, octave: 5);
    pitch1.pitchClass.postln; // 9
    pitch1.octave.postln; // 5
    pitch1.midiNoteNumber.postln; // 69
    pitch1.frequency.postln; // 440

    var pitch2 = TWPitch.newPitchWithMIDINoteNumber(noteNumber: 69);
    pitch2.pitchClass.postln; // 9
    pitch2.octave.postln; // 5
    pitch2.midiNoteNumber.postln; // 69
    pitch2.frequency.postln; // 440
)

TWPitch calculates frequency based on a reference frequency that defaults to 440Hz. You can change the reference frequency globally for all instances of TWPitch:

TWPitch.setReferenceFrequency(442.0);

If the new reference frequency does not relate to the note A in the 5th octave, you will also need to change the reference pitch class and octave:

// Set the reference frequency to approximately C (pitch class 0) in the 4th octave (slightly flat):
TWPitch.setReferenceFrequency(130.8);
TWPitch.setReferencePitchClass(0);
TWPitch.setReferenceOctave(4);

(
    var pitch = TWPitch.newPitch(pitchClass: 9, octave: 5);
    pitch.pitchClass.postln; // 9
    pitch.octave.postln; // 5
    pitch.midiNoteNumber.postln; // 69
    pitch.frequency.postln; // ~439.957
)

TWPitch can also provide a MIDI-compatible octave number. By default, the MIDI octave is equal to pitch.octave - 1. This is appropriate for most MIDI systems. Some systems (eg. Yamaha) use pitch.octave - 2, which can be obtained by adjusting the MIDI base octave:

(
    var pitch1 = TWPitch.newPitch(pitchClass: 9, octave: 5);
    pitch1.octave.postln; // 5
    pitch1.midiOctave.postln; // 4
)

TWPitch.setMIDIBaseOctave(-2); // Allowable range is -2..0

(
    var pitch2 = TWPitch.newPitch(pitchClass: 9, octave: 5);
    pitch2.octave.postln; // 5
    pitch2.midiOctave.postln; // 3
)

TWDuration

TWDuration describes a note duration as a fraction, in which the denominator represents a division of a typical 4 beat measure (eg. 4 for a quarter note or 8 for an eighth note) and the numerator represents the number of divisions:

var wholeNote = TWDuration.newDuration(numerator: 1, denominator: 1);
var halfNote = TWDuration.newDuration(numerator: 1, denominator: 2);
var quarterNote = TWDuration.newDuration(numerator: 1, denominator: 4);
var eighthNote = TWDuration.newDuration(numerator: 1, denominator: 8);
var sixteenthNote = TWDuration.newDuration(numerator: 1, denominator: 16);
var dottedHalfNote = TWDuration.newDuration(numerator: 3, denominator: 4);
var dottedQuarterNote = TWDuration.newDuration(numerator: 3, denominator: 8);
var eighthNoteTriplet = TWDuration.newDuration(numerator: 1, denominator: 12);
var quarterNoteTriplet = TWDuration.newDuration(numerator: 2, denominator: 12);

The value of a TWDuration can be calculated as a decimal value:

(
    var duration = TWDuration.newDuration(numerator: 1, denominator: 8);
    duration.decimal.postln; // 0.125
)

As a clock value, which can be used with SuperCollider's Task object:

(
    var duration = TWDuration.newDuration(numerator: 1, denominator: 8);
    duration.clock.postln; // 0.5
)

Or as time in seconds or milliseconds. Time calculations are based on a reference tempo, which defaults to 60 beats per minute. You can change the reference tempo globally for all instances of TWDuration:

(
    var duration1 = TWDuration.newDuration(numerator: 1, denominator: 8);
    duration1.seconds.postln; // 0.5
    duration1.milliseconds.postln; // 500
)

TWDuration.setReferenceTempo(120.0);

(
    var duration2 = TWDuration.newDuration(numerator: 1, denominator: 8);
    duration2.seconds.postln; // 0.25
    duration2.milliseconds.postln; // 250
)

TWNote

TWNote describes a note as a combination of a pitch (an instance of TWPitch) and a duration (an instance of TWDuration). TWNote objects also have a boolean property named isRest that indicates whether or not the note should be treated as a rest. (It is the responsibility of the code that interprets the note to handle the rest properly.)

(
    var note = TWNote.newNote;
    note.pitch.postln; // a TWPitch
    note.duration.postln; // a TWDuration
    note.isRest.postln; // false
)

TWNote has several constructors:

// Verbose constructor:

(
    var note1 = TWNote.newNote(
        pitch: TWPitch.newPitch(
            pitchClass: 9,
            octave: 5),
        duration: TWDuration.newDuration(
            numerator: 1,
            denominator: 4),
        isRest: false);

    note1.pitch.pitchClass.postln; // 9
    note1.pitch.octave.postln; // 5
    note1.pitch.midiNoteNumber.postln; // 69
    note1.pitch.frequency.postln; // 440
    note1.duration.decimal.postln; // 0.25
    note1.isRest.postln; // false
)

// Convenience constructors:

(
    var note2 = TWNote.newNoteWithPitchClass(
        pitchClass: 9,
        octave: 5,
        durationNumerator: 1,
        durationDenominator: 4);

    note2.pitch.pitchClass.postln; // 9
    note2.pitch.octave.postln; // 5
    note2.pitch.midiNoteNumber.postln; // 69
    note2.pitch.frequency.postln; // 440
    note2.duration.decimal.postln; // 0.25
    note2.isRest.postln; // false
)

(
    var note3 = TWNote.newNoteWithMIDINoteNumber(
        noteNumber: 69,
        durationNumerator: 1,
        durationDenominator: 4);

    note3.pitch.pitchClass.postln; // 9
    note3.pitch.octave.postln; // 5
    note3.pitch.midiNoteNumber.postln; // 69
    note3.pitch.frequency.postln; // 440
    note3.duration.decimal.postln; // 0.25
    note3.isRest.postln; // false
)

(
    var rest = TWNote.newRest(
        durationNumerator: 1,
        durationDenominator: 4);

    rest.duration.decimal.postln; // 0.25
    rest.isRest.postln; // true
)

Sequencing TWNote Objects With Tasks

SuperCollider's Task object provides a convenient and powerful way to sequence events that works well with TWNote. You can build simple sequence with a list of TWNote objects:

(
    // Create a global clock using the TWDuration reference tempo:
    ~clock = TempoClock.new(TWDuration.referenceTempo / 60.0);

    var sequence = Task({[
        TWNote.newNoteWithPitchClass(pitchClass: 0, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 4, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 5, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 11, octave: 4, durationNumerator: 1, durationDenominator: 4)
        ].do({
            // The .do function receives the note object as its first argument:
            arg note;
            // Print the note's frequency:
            note.pitch.frequency.postln;
            // Wait for the duration of the note's clock value:
            note.duration.clock.wait;
        });
    }, ~clock);

    sequence.play;
)

Now add a simple SynthDef to play each note in the sequence:

// Boot the local server:
Server.default = s = Server.local.boot;

(
    SynthDef(\osc, {
        arg frequency = 440.0, duration = 1.0;
        var attack = 0.05;
        var decay = 0.1;
        var hold = duration - (attack + decay);
        var osc = SinOsc.ar(
            freq: frequency,
            mul: EnvGen.kr(
                envelope: Env(
                    levels: [0.000001, 0.1, 0.1, 0.000001],
                    times: [attack, hold, decay],
                    curve: \exponential
                ),
                doneAction: 2)
        );
        Out.ar([0, 1], osc);
    }).load(s);
)

(
    // Create a global clock using the TWDuration reference tempo:
    ~clock = TempoClock.new(TWDuration.referenceTempo / 60.0);

    var sequence = Task({[
        TWNote.newNoteWithPitchClass(pitchClass: 0, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 4, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 5, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 11, octave: 4, durationNumerator: 1, durationDenominator: 4)
        ].do({
            // The .do function receives the note object as its first argument:
            arg note;
            // Use the time in seconds for the synth duration:
            Synth(\osc, [frequency: note.pitch.frequency, duration: note.duration.seconds]);
            // Wait for the duration of the note's clock value:
            note.duration.clock.wait;
        });
    }, ~clock);

    sequence.play;
)

Polyphonic sequences can be created by combining multiple Task objects. Notice how rests are handled in sequence2:

// Boot the local server:
Server.default = s = Server.local.boot;

(
    SynthDef(\osc, {
        arg frequency = 440.0, duration = 1.0;
        var attack = 0.05;
        var decay = 0.1;
        var hold = duration - (attack + decay);
        var osc = SinOsc.ar(
            freq: frequency,
            mul: EnvGen.kr(
                envelope: Env(
                    levels: [0.000001, 0.1, 0.1, 0.000001],
                    times: [attack, hold, decay],
                    curve: \exponential
                ),
                doneAction: 2)
        );
        Out.ar([0, 1], osc);
    }).load(s);
)

(
    // Create a global clock using the TWDuration reference tempo:
    ~clock = TempoClock.new(TWDuration.referenceTempo / 60.0);

    var sequence1 = Task({[
        TWNote.newNoteWithPitchClass(pitchClass: 0, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 4, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 5, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 11, octave: 4, durationNumerator: 1, durationDenominator: 4)
        ].do({
            // The .do function receives the note object as its first argument:
            arg note;
            // Use the time in seconds for the synth duration:
            Synth(\osc, [frequency: note.pitch.frequency, duration: note.duration.seconds]);
            // Wait for the duration of the note's clock value:
            note.duration.clock.wait;
        });
    }, ~clock);

    var sequence2 = Task({[
        TWNote.newRest(durationNumerator: 2, durationDenominator: 12),
        TWNote.newNoteWithPitchClass(pitchClass: 0, octave: 6, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 11, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 9, octave: 5, durationNumerator: 1, durationDenominator: 4),
        TWNote.newNoteWithPitchClass(pitchClass: 7, octave: 5, durationNumerator: 1, durationDenominator: 12)
        ].do({
            arg note;
            // Do not play the synth during rests, but do wait out the duration:
            if (note.isRest.not, {
                Synth(\osc, [frequency: note.pitch.frequency, duration: note.duration.seconds]);
            });
            note.duration.clock.wait;
        });
    }, ~clock);

    var polySequence = Task({
        sequence1.play;
        sequence2.play;
    }, ~clock);

    polySequence.play;
)

Be sure to check out the full documentation for TWNote, TWPitch and TWDuration. Documentation and help for the SuperCollider language is available at doc.sccode.org.

Check out the source on Github.

Check out the source on Github.

0:  C
1:  C sharp / D flat
2:  D
...
9:  A
10: A sharp / B flat
11: B

Octaves are identified by integers ranging from 0 to inf. Pitch class 0 in octave 0 produces C at ~8.176Hz. Pitch class 9 in octave 5 produces A at 440.0Hz.

Check out the source on Github.

If you care about iOS and OS X at all and still haven't seen the keynote, it's worth a few hours of your time. If you're an iOS developer, you need to bring yourself up to date with the new design language in iOS7, UIKit Dynamics, Multipeer Connectivity and SpriteKit (even if you aren't a game dev) first. They will change how you design your apps. The session videos are available in the WWDC app now.

A lot of apps are going to have to undergo significant change to look and feel right in iOS7. Within a day of the announcement I started planning a ground up redesign of Taxulator, inside and out. A simple freshening isn't going to cut it. It's time to rethink how the app works and how users will interact with it. Taxulator was the first app I built for the "old" iOS and I'm excited to bring it to iOS7, hopefully in time for the official release.