Command-Tab

Importing Certificates into Xcode 27's Device Hub

2026-06-12T21:14:00Z

Xcode 27 introduced, among other new features, a new Device Hub app for developers that takes the place of the Simulator app. Where Simulator relied on separate windows for each device, Device Hub brings them all together into a single window where each simulated device is the detail view from a source list of devices on the left. It’s a more organized approach, made necessary by the wide variety of platforms Apple and Apple platform app developers have to build and test against.

For enterprise users or developers building apps that communicate with web services over HTTPS, those services need to be using a certificate pair signed by a globally-trusted authority like DigiCert or Let’s Encrypt for them to work “out of the box” in the simulated OS. If they are using a certificate pair signed by a self-signed or in-house/enterprise CA (Certificate Authority), the OS will refuse to connect, displaying a “This connection is not private” interstitial in Safari or failing with a TLS trust error like NSURLErrorServerCertificateUntrusted. Even if the host Mac has the CA root certificate installed and trusted, the simulated devices rely on their own per-virtual-device trust store.¹

In releases prior to Xcode 27, you could resolve this by importing the root public certificate into the simulated OS. On iOS, this could be done by dragging and dropping the .cer file onto the Simulator device window. Nothing would appear to happen, but you could then navigate to Settings, General, About, Certificate Trust Settings and mark the certificate as trusted. On tvOS, the process was even more complex, requiring you to open Settings, General, Privacy & Security, hold down the virtual remote’s Play button on the Share AppleTV Analytics option to bring up a hidden dialog, then enter an HTTP URL to a .cer file. Similar to iOS, you’d have to mark it as trusted by navigating tvOS to Settings, General, About, Certificate Trust Settings and enabling the switch for that certificate. This process was slow and, especially on tvOS, quite obscure.

In Xcode 27 with Device Hub, this process is much more uniform.

Open Apple Configurator and create a new profile.
Under General, give the profile a name, a unique identifier, and perhaps an organization name.
Under Certificates on the left, click the Configure button and choose the .cer file you wish to install into the simulated OS.
From the File menu, choose “Sign Profile…” and select a developer identity to sign with. Alternatively, you can sign profiles from the command line with security cms -S -N "My Signing Identity" -i unsigned.mobileconfig -o signed.mobileconfig.
In Device Hub, select the target device, then open the Profiles tab in the right-side device inspector.
Click the plus button below the list and choose the .mobileconfig file you just signed.
The profile and its contained certificate should be immediately installed into the simulated OS. In iOS, you can verify by navigating to Settings, General, VPN & Device Management, and on tvOS the list of installed profiles is at Settings, General, Profile.

While this new process does require you to wrap certificates in an Apple Configurator profile, this is much more consistent with how Apple’s device management system works, as it relies on signed profiles with policies, not loose .cer files. And now, just by adding the .mobileconfig to the Profiles section of the device inspector, the embedded certificate is automatically marked as trusted, greatly speeding up installation on new virtual devices.

Much like Simulator devices, Xcode’s built-in SwiftUI Previews rely on their own dedicated trust store separate from both the host Mac and Simulator/Device Hub devices, but there’s seemingly no way to configure certificates in that SwiftUI Preview environment. Apple folks, please see FB10667327. ↩

Macrochips

2026-06-03T00:48:51Z

I was so inspired by Jason Coon’s macrochips project – 4” slate drink coasters laser-engraved to look like notable chips from computing history – that I had to design and make some of my own. I don’t own a laser cutter, but the local hardware store had one available, and I was able to convince them to let me engrave similar slate coasters despite them not being among their pre-defined set of available engraving targets (keychains, mugs, and the like). But what to pick? I decided to go with some chips that were meaningful to me:

Apple A17 CPU
Nintendo 64 CPU
Sony PlayStation CPU
Broadcom Raspberry Pi 5 CPU
NVIDIA Media and Communications Processor (from the original Xbox)
IBM PowerPC 603 CPU (from early PowerPC Macs)
Motorola PowerPC G4 CPU (from later PowerPC Macs)
AMD K6 CPU
Intel i386 EX CPU

The hardest part of designing these was tracking down vector versions of some of these companies’ now-obsolete logos, extracting them from PDF files and datasheets, but I think the designs turned out pretty good:

Once designed, it was time to hand them off to the laser cutter:

It was fun to watch the designs get laid down by the laser cutter:

The results turned out alright:

Though, there were a number of text layers I forgot to convert to outlines, so the engraving prep software replaced them with Myriad instead of the specific fonts I had chosen. As well, a few early attempts were also a little mis-aligned. I could certainly do better if I had time to sit and make adjustments with my own laser cutter…

Indiana Jones and the Great Circle

2026-05-31T03:37:17Z

I finally caught up to 2024 and finished playing Indiana Jones and the Great Circle to 100%. I had been putting off starting the game for some time because I’m really not much of a gamer, and I find it oddly difficult to internalize new game control schemes and menu systems. But once I finally picked up the controller, it didn’t take long to get acquainted with the intuitive grip and whip system, and I’m so glad I did, because this game is really something special.

Look and Feel

MachineGames did a fantastic job at matching the feel of the source material. The levels are dense with detail, the typography looks just right, and there are both first person in-game and third person cutscene references to the films’ cinematic choices at every turn. Most notably, the use of hard contrasting light and shadow appears fairly often while exploring. Following along with the game’s story feels like enjoying a lost installment from the original trilogy, which is a bar I didn’t expect it to clear going in.

Carefully placed spotlights and torches regularly cast Indy’s recognizable shadow.

Light reveals Indy’s eyes when he’s making a connection or solving a puzzle.

Open Kapitalen and Eurostile Extended welcome you to new regions and lend film authenticity.

Choosing a mostly first-person adventure also seemed like a big development risk. For an iconic character like Indiana Jones, it’s definitely a choice to not show him for large swaths of the game. To make it convincing, they had to lean hard into what it would be like to be Indiana Jones. So much would revolve around what you can do with your hands and whip and items. Therefore, that in-game system had to feel very comfortable to use and be pretty extensive. I had played a few previous Indiana Jones (and of course, Tomb Raider) games which were all third person, so going in, I thought first person would be weird or off-putting, but this game does it so well that I now prefer it over third person or over-the-shoulder views.

The developers clearly spent a lot of time studying the films. They picked up so many of Indy’s smirks, quirks, and mannerisms, and when combined with Troy Baker’s shockingly accurate voiceover work, you’d be surprised to learn it wasn’t voiced by and motion captured from Harrison Ford himself. The humor from the films is also ever present and used to great effect. Even beyond the dialogue, the yells, grunts, and exclamations all sound so perfect, capturing Indy’s intonation well.

What really put it over the top for me, though, is the music and sound. The game features a lovely and familiar score, threading John Williams’ original themes through new material in a way that sounds completely organic and unforced, rather than just quoting the Raiders March and calling it a day. As well, the sound effects are also very much on point, with whip, punch, and gunfire having the signature cracks, thuds, and pops that seem right out of the films.

There are a few behind-the-scenes videos that go deep into all of this, and I watched them with a big stupid grin on my face. Hearing the development team talk about watching the films together, cataloging the core details that had to be right, and obsessing over everything clearly paid off.

It’s also just a gorgeous game. The id Tech 7 engine looks incredible on modern devices, rendering lighting and geometry in more detail than I’m used to in games (again, I don’t play a ton of games). The amount of just stuff to see in the levels is impressive. I can’t even imagine how long it took to set-dress all these areas. Notably, many of these items can be used as weapons or distractions, including wrenches, frying pans, mops, and bottles.

Just marvel at the level of detail achieved here: The fine individual hair, the wear on the seams of the leather jacket, the distressed fur felt on the fedora, and the specular highlights on the sclera of the eyes.

Every region has loads to explore, little sub-plots to follow, and NPCs going about their business. Some casually relay details or hints towards as-yet-unsolved puzzles.

Gameplay

The game heavily encourages you to lean on Indy’s punch and whip maneuvers rather than using his revolver. Ammo isn’t something to be spent carelessly. Rather, you save it for the moments when you get into a jam that’s larger than you can otherwise take on. But the cost of using a loud weapon is that nearby enemies will overhear it, blow the whistle on you, and rally reinforcements, so you need to pick and choose your battles carefully rather than playing it like a run-and-gun first person shooter. While not a stealth game, climbing, disguise, distraction, and a healthy dose of hand-to-hand combat will get you further than running headlong into battle. Certain classes of enemies will also see through your various disguises and similarly call attention to you, so you need to be aware of who’s nearby.

Attention to detail is everywhere in this game. Here, the number of remaining shots in the heads-up display corresponds to the number of visibly unfired rounds in the revolver. The reload animation has Indy individually pluck out spent rounds and replace them, rotating the cylinder for each.

The game balances exploration, discovery, collection, puzzle solving, and storytelling well. I rarely found myself spending too much time doing any one of those activities. The puzzles aren’t particularly difficult, with key items often just in adjacent crawlspaces, but they’re also not too simple. They feel calibrated to make you think, but aren’t so onerous that they impede advancing the story.

Along the way, you pick up money, bandages, food, local maps, and Adventure Books that expand your capabilities. The books are the game’s skill system, where you can improve your abilities like reducing reloading time, increasing damage dealt against enemies, or boosting climb and run stamina, and finding them is a nice reward for exploration. Once learned, they make future encounters progressively more achievable and boost your confidence to take swings at more aggressive confrontations. Indy is a scholar and a problem-solver first, so getting better at the job through research feels like the right approach.

Acquiring and reading Adventure Books boosts combat, survival, brawling, etc.

Even the Pause menu looks like it belongs. Also, hey, it’s me: I’m mac_minded on PlayStation and Mac Minded on Xbox.

That Belongs in a Museum

The Order of Giants DLC is a worthwhile addition, though it left me wanting even more time in this world. What MachineGames accomplished here is astounding. Licensed games based on beloved properties like Indiana Jones have a history of often getting surface details right but missing what actually made the source material work. This one didn’t miss. It understood what Indiana Jones is about well enough to make a game that genuinely belongs on the same shelf as the films. I don’t know if it will happen, but I would very much love a sequel.

Using uv with RedHat Python Images

2026-04-26T04:38:01Z

When deploying web apps, I use containers almost exclusively. Containerization lets you package up everything your app needs and ship all of it to a container runtime in a single archive. While it has some drawbacks, it’s still a significant net improvement over web app deployment methods that pre-date it.

I use uv to install dependencies into a container image, but I typically don’t want to create a Python virtualenv within the container because then there are two levels of isolation to contend with. Just the container alone is sufficient. However, I still want all the benefits of using uv, particularly the specific tree of dependency versions and their hashes listed in the uv.lock file. For this reason, I configure uv to install the listed dependencies into the container’s “system” Python at install time, rather than a virtualenv .venv/ directory:

FROM registry.redhat.io/rhel9/python-312:latest

WORKDIR /opt/app-root/src

# Use the "system" Python for uv (the container's)
ENV UV_SYSTEM_PYTHON=1
ENV UV_PROJECT_ENVIRONMENT=/opt/app-root

# Install uv
RUN pip install --upgrade pip==26.0.1 && pip install --upgrade uv==0.11.4

# Copy only dependency files first to cache the dependency installation as its own container image layer.
# --active: prefer the environment specified by VIRTUAL_ENV (in the upstream RedHat Python base image)
# --frozen: treat the versions in uv.lock as the source of truth and skips updating the lockfile
# --no-dev: skip dev dependencies, since this is a non-development environment
# --compile-bytecode: compile Python files to .pyc files to trade CI build time for faster container start time
# --no-python-downloads disables automatic downloads of Python so we use the container's
COPY pyproject.toml uv.lock .
RUN uv sync --active --frozen --no-dev --compile-bytecode --no-python-downloads

# Copy the rest of the codebase in a separate layer
COPY . .

CMD ["granian", "app:app"]

Those options will use uv to install dependencies into the container-provided Python environment at /opt/app-root/ in the Python image rather than creating a new virtualenv at /opt/app-root/src/.venv/. With this, you can omit uv run ... from container commands, cron jobs, etc. Opening a shell into this container will drop you into a place where the dependencies are installed and readily available without having to activate a virtualenv, prefix tool invocations with uv run, or specify a container ENTRYPOINT).

Push Notifications with Brrr

2026-04-21T00:13:14Z

iOS developer Simon Støvring recently launched Brrr, a convenient and low-friction web service and corresponding iOS app deliver push notifications to your iOS devices using only an HTTP request. In this way, it can integrate with almost any service or device that is internet-connected. Options allow you to customize the notification content, alert sound, destination URL, image, and more.

Brrr fills the particular niche of when you want a quick notification from a script, a cron job, or home automation trigger without building your own push notification infrastructure. It’s not the first app of its kind to do this, but it does so very simply. And at $9.99/year, it’s very reasonably priced for what it does.

A Decade and Counting

2026-04-20T03:02:01Z

In 2023, I shared this anecdote at the Pixar Anniversary Awards celebration for people who reached 10 years of employment:

I was late on my first day at Pixar. I’m not one of those perpetually-late-to-everything people. I pride myself on being on time or earlier for events. But on my first day at Pixar in the summer of 2013, I wildly underestimated how long it would take to get from the North Bay to Emeryville during morning rush hour traffic.

As the minutes ticked over my scheduled orientation start time, my palms were starting to sweat against the steering wheel. Cars were barely inching along, and the time kept getting later and later. Soon, the recruiter I had been working with started calling and urgently asking, “Are you still coming?”, and I swore that I was indeed still on my way and it would just be a little longer. Taking a risk, I swerved into the carpool lane for the last mile or so and I arrived “only” 40 minutes late and bolted into the Steve Jobs Building. Graciously, they rushed me over to the theater to catch up with everyone else to watch a screening of Party Central at what seemed like maximum volume, which was a hell of a way to kick start a morning.

So, I want to thank my recruiter for not turning me away when I finally arrived, and want to thank everyone at Pixar for being such a truly wonderful group of people. I love working with all of you and look forward to the next decade. I promise I’ll be on time.

It’s been a few years since that ceremony, and Pixar continues to be a place where I want to do my best work. The care and enthusiasm everyone pours into their particular craft is, I hope, evident in our body of work.

What inspires me to do my best work? A few things I’ve identified over the years.

The first and most important, I think, is being given the authority and autonomy to gather requirements for, design, engineer, and ship tools that help people get their job done. These tools provide users with more time to focus on doing creative work rather than wrangling minutiae, and it’s rewarding to be able to turn an idea into a released product without a bunch of red tape.

Working alongside people who genuinely give a damn about their work also matters too, particularly people will give honest critical feedback when my own work isn’t up to par. We hold each other’s standards high, and do so with respect, where the goal is to lift up the work and not drag the other person down. And very often the best technical solutions win because the right answer, once someone speaks it into the room, is clear to all involved and we move forward in agreement.

There’s also the proximity to the actual creative work. The end users of the tools I create are animators, producers, production staff, and so on. When my tools work well, it ripples into a film, even though I’m not among those who touch the film’s pixels directly.

Finally, there’s the constraint of a specific, known audience.¹ Building for co-workers is different from building for “users.” I know many of them by name. That specificity tends to produce more considered work than if I’m building for an abstraction. And the feedback I get about the work is everywhere, from conversations in Slack to spontaneous “Hey, wouldn’t it be cool if…?” spitballing in the lunch line.

None of this is a recipe, and I’m not sure it’s replicable. These are conditions I largely stumbled into, often by luck and the kindness of others, and only later learned to recognize as what was making the work feel meaningful. After more than a decade in, I’m still here, which probably says something about how rare that is to find.

Building for a specific audience is also convenient and beneficial from a technical standpoint because the target devices are a much more limited and homogenous set, for example, modern “evergreen” browsers and Apple platforms. I can therefore take advantage of new features and APIs quite readily, and more quickly deprecate and remove cruft. ↩

Going Electric

2026-04-16T04:05:37Z

I am done with gasoline and I’m never going back. Early last year, I sold my gasoline-powered car and went all in on an electric vehicle. I skipped right over hybrids, which I viewed as being burdened with the additional complexity of having to haul around two sources of locomotion. I figured that if I was going to try something new, I should just make the switch and not try to hedge against the new thing at the cost of added complexity and maintenance. Electric vehicles are well enough established (particularly in California) that there was little reason to avoid making the jump, and I’m so glad I made the switch.

After checking out everything from the large F-150 Lightning down to a petite little Chevy Bolt, I settled on a used 2022 Volkswagen ID.4 which had just come off lease. With only about 20,000 miles on the odometer, it was still very much like new. But the fact that it was previously a lease meant it was likely handled carefully, and the fact that it was now used meant it was extremely affordable for an EV at a time when EVs are often more expensive than gas vehicles. I ended up paying about $25,000 for it, and that felt like a steal for what I got.

This being my first EV, I was initially a little bit wary about going electric, but now that I have a year’s worth of daily-driver experience with the technology, it’s so crystal clear to me that this is the future of vehicles and that the internal combustion engine’s best days are behind it. It feels like a seismic shift both in the way I drive and use energy.

Like most EVs, the ID.4 has some really great features. The very first difference you notice is the instant acceleration. You start moving the moment you press the pedal. The best way to describe it is like the difference between pre-iPhone touchscreens which often struggled to keep up with the movement of your finger, whereas the iPhone made the screen contents feel like they moved directly with your finger. EV acceleration feels tactile and direct, rather than propagated through a buffer delay. Because it’s electric, the ID.4 moves so smoothly and quietly that it really feels like a much more expensive luxury car. It also has a tight turning radius and can thus easily achieve a 180 degree turn-around inside the width of a narrow street without having to perform a multi-point turn.

I was coming from a 2009 Toyota Corolla base trim, so many of the features of the ID.4 are just the current state of vehicles made within the last decade and not EV exclusives, but are nonetheless delightful to have, including:

Illuminated exterior and (RGB) interior handles
Comfortable heated seats
Heated steering wheel
Remote climate control
Back up camera
Side mirror lane occupancy indicators
Built-in USB-C ports
Apple CarPlay

CarPlay, in particular, was a must-have. The Chevy dealer tried to convince me that GM’s Bluetooth solution was still very good, but I wasn’t having that at all. The ID.4 also has walk-up unlock, walk-away lock, and auto-enters Park, so I never really think about what mode the car is in: I walk up (it unlocks), I get in, buckle, drive somewhere, stop, unbuckle (it enters Park), then I just get out and walk away (it locks). I never have to think about turning it on or off myself, making for a frictionless experience.

The ID.4 has two drive modes, “D” and “B”. D mode (the default Drive mode) makes the car drive much more like gas car, with the ability to coast for longer distances and do little regenerative braking. But toggle into B mode and the car behaves more like its true EV self, doing more aggressive regenerative braking when you ease off the accelerator pedal, allowing you to recover some electricity while cornering or going downhill. It took a short few days before B mode was far and away my preferred mode, making the D mode (and thus the behavior of gas cars) feel almost slippery by comparison.

The major consideration when choosing an EV is how and when you’ll charge the battery. Chargers are popping up in more and more places, but you very likely spend a lot of time not driving with the car parked somewhere for hours at a time. That’s probably the best time and place to charge. A couple years ago, we installed a modest home solar and battery storage system, and adding a home EV charger (Level 2 @ 220V 40A) charger later was a straightforward addition. While I could have achieved sufficient charging without any special charger using a regular household plug (Level 1 @ 110V 15-20A), the Level 2 home charger makes filling up my car only take a few hours and is easily done while I’m sleeping or working from home while the sun is shining on the solar panels. Powering my car is now effectively free using energy from the sun instead of disposable energy from oil. I can plug in at convenient times and almost always have a “full tank” ready to go without having to consider the gas station on the way home since my home is the station. And so is my work. And the grocery store. Almost every destination has something available or nearby, but having a sufficient charger at home is what really puts “range anxiety” fears to rest.

On the interior, one of the compelling reasons for choosing the ID.4 was its minimalist, unadorned heads-up display. The dashboard user interface is big, bright, and clear, with simple numerals for the speed, flanked by cruise control and next-turn instructions (which can use the built-in navigation or CarPlay). This approach was not true for the Kia Niro, which had a fake analog speedometer needle and gradients and shadows abound.

There are a few things that could be better, though:

The steering wheel and center console use touch controls, and while they’re not easy to press accidentally, they do require you to look away from the road to adjust. In my Corolla, I could adjust the heat mode, fan speed, and temperature by feel alone, and that felt safer. VW is, thankfully, moving away from touch controls in future models.
Remote climate control sometimes takes a minute or more to respond. I never had this feature at all before, though, so any availability was still a welcome feature.
Wireless CarPlay is convenient, but a little laggy and skips occasionally. This might just be wireless CarPlay’s fault and not VW’s. Wired CarPlay via USB-C works reliably, is very responsive, and charges my phone faster than the available Qi charger (and with less heat).
I wish the VW app had a web app counterpart. How hard could this be, given they already have an app?

Minor gripes aside, none of these are dealbreakers. Overall, the ID.4 is a competitively priced EV that was, for me, a great entry into the world of electric vehicles. My experience so far has been extremely positive, and if it were totaled, I would buy one again in a heartbeat. I’m never buying a gasoline-powered anything again.

Running Nuxt 3 Behind an nginx Reverse Proxy

2022-04-25T01:47:06Z

I was attempting to run Nuxt 3 RC1 in development mode behind a local nginx reverse proxy, but ran into several issues. There are a number of reasons to run a development application server behind a TLS-terminating reverse proxy, including more closely mirroring a production setup, ensuring an application performs correctly when proxied, and gaining HTTPS support to enable use of newer HTTPS-only user-agent APIs.

However, when nginx reverse proxies to the Nuxt server using a configuration like the following, the application will load correctly in the browser but Vite (bundled with Nuxt) will no longer be able connect to its backend websocket server to provide hot module replacement (HMR).

location / {
  proxy_pass http://127.0.0.1:3000;
  proxy_set_header X-Real-IP $remote_addr;
  proxy_set_header Host $host;
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}

To fix this, Vite needs to be made aware it’s being reverse proxied, and nginx needs to pass through Vite’s websocket connection.

In the Nuxt config (nuxt.config.ts), add the following Vite config:

vite: {
  server: {
    hmr: {
      protocol: 'wss',
      clientPort: 443,
      path: 'hmr/'
    }
  }
}

Vite will now use the secure websocket protocol over the same HTTPS port as the application, but it will request it at a new, distinct path.

In the nginx config, add a new location directive to match the configured Vite path (/_nuxt is always prepended), have it perform an HTTP Upgrade, and then reverse proxy to Vite’s websocket server, which always listens on port 24678:

location /_nuxt/hmr/ {
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "Upgrade";
  proxy_pass http://127.0.0.1:24678;
}

After restarting the development server and nginx, Nuxt 3 and Vite HMR work great behind nginx, which now handles TLS termination and reverse proxying of HTTP and websocket traffic.

Update 2023-09-28

As of Nuxt 3.7.4, the nuxt.config.ts configuration is unnecessary, though having the following nginx config in place avoids a WebSocket error about the WebSocket host being undefined:

location /_nuxt/ {
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
    proxy_pass http://127.0.0.1:3000;
}

Note the differences from the above config – the location path dropped hmr/, the Vite HMR port (24678) became the default Nuxt port (3000), and the Host header was also added (but the Host header is likely not critical for this scenario).

Update 2026-03-23

Tangentially related: In development, Nuxt Icon collections are loaded from the Nuxt server at /api/_nuxt_icon, but this path might introduce a conflict if you are integrating a completely separate non-Nuxt API at /api. In my case, I often have a Python API expecting requests bearing that path prefix. My local nginx setup forwards requests with /api prefixed paths to Python, resulting in a Nuxt 404 on Nuxt Icon collection manifests such as /api/_nuxt_icon/bi.json?icons=escape or /api/_nuxt_icon/solar.json?icons=check.

Setting a localApiEndpoint overrides the default value of /api/_nuxt_icon both in how the Nuxt server route is offered and how the Nuxt client requests the collection JSON. The issue and fix are both documented on GitHub. In nuxt.config.ts, add something like the following:

icon: {
  localApiEndpoint: '/_nuxt_icon',
},

Note that /api is absent from the value of localApiEndpoint, durecting Nuxt Icon to use a path other than /api/_nuxt_icon. Anything that will not be picked up by an external API is valid here, and will make the Nuxt Icon module work again.

Building cen64 on macOS

2020-01-12T03:15:14Z

For testing Nintendo 64 homebrew ROMs, cen64 is the most accurate emulator (though it doesn’t run at full speed yet). Here’s how to build it from source on macOS:

Install XQuartz from the official distributed disk image
brew install cmake glew
git clone https://github.com/n64dev/cen64.git
cd cen64
mkdir build
cd build
cmake ..
make

If you’d like to enable cen64’s debug logging, create a debug build when running cmake:

cmake -DCMAKE_BUILD_TYPE=Debug ..

When running cen64 outside of an XQuartz X11 terminal, it may report:

Using NTSC-U PIFROM
create_device: Failed to initialize the VI.
Failed to create a device.

To fix this, you can run it within an XQuartz X11 terminal, or set the DISPLAY environment variable to something like :0 either in your .bashrc file or inline during invocation:

DISPLAY=:0 ./cen64 /path/to/pifdata.bin /path/to/rom.z64

DISPLAY needs to be set because cen64 calls XOpenDisplay with a NULL display name (presumably to default to your DISPLAY environment variable), but if it’s not set, XOpenDisplay returns NULL and cen64 has no display within which to create a window for rendering Nintendo 64 content.

For extremely verbose register-level output, edit CMakeLists.txt and set DEBUG_MMIO_REGISTER_ACCESS to ON. Make sure to remove any cached data in build/ to ensure your changes are reflected, then recompile and re-run.

Update 2024-03-02

Development on cen64 has not progressed in many months and is now considered unmaintained. ares, a cross-platform, open source, multi-system emulator is now regarded as the best emulator for Nintendo 64 development.

BrewBot - Sending Coffee Notifications to Slack

2017-09-17T02:01:47Z

At work, we have a coffee machine that serves dozens of people in the building, and it’s difficult to know when to come get fresh coffee. You might arrive when it’s empty and be tasked with making more, but the ideal situation is to arrive just as a fresh pot is being brewed.

We also use Slack for team chat and various notifications, so integrating the coffee machine status was a no-brainer. Using a non-invasive/inductive current sensor and Raspberry Pi, the following setup monitors coffee machine energy consumption and waits for a significant rise in current draw, followed by several minutes of sustained usage. Once a time threshold has passed, it does an HTTP POST to a Slack webhook, sleeps for about 15 minutes, then starts monitoring again. This “brewbot” code is available on GitHub, and a parts list can be found below.

Full parts list:

MCP3008 8-Channel 10-Bit Analog to Digital Converter
Raspberry Pi model B
16-pin IC socket
Assortment of heat shrink tubing
Panel mount to Micro USB adapter
10KΩ 1/4W LED resistor
Half-size Perma-Proto Raspberry Pi Breadboard PCB Kit
5mm Yellow LED
1/8” panel mount audio jack
10uF electrolytic decoupling capacitor
33Ω 1/2W burden resistor
2x 470KΩ 1/2W voltage divider resistors
30A non-invasive current sensor
22 AWG Solid Core Hook Up Wire
5x7 photo box, from The Container Store
8 GB Class 10 SDHC card
Edimax EW-7811Un Wireless Nano USB Adapter
6x Nylon screws washers and nuts
8” AC Cord Clips
HDMI to Mini HDMI adapter
6’ Mini HDMI to HDMI Cable
10’ USB A Male to B Male Cable

Related reading: Hyper Text Coffee Pot Control Protocol

GottaGo

2013-07-23T20:46:02Z

Working at Blackboard Mobile making unique mobile apps is fun, but occasionally it’s interesting to do something completely different at work, just to see what you can come up with. To that end, we recently hosted our first Hackathon, where small teams of co-workers had 24 straight hours to create a project of any theme using resources available inside our outside of the office, and the results would be judged by our peers. One of the other benefits of working in a growing industry is that we’re expanding our staff almost weekly. Unfortunately, though, that means that the building we’re in is less and less able to handle the increasing capacity. Specifically, the bathrooms are occupied more frequently, resulting in either a return trip to your desk only to try again later, or an awkward wait of unknown duration.

Working with Joe Taylor and Eric Littlejohn, our Hackathon project set out to make the office bathroom availability more visible and accessible through a combination of hardware and software. The piece of the project that lets this all work is a microswitch installed inside each door jamb, such that when the locking bolt is engaged, the switch is tripped. That way, we can do anything with resulting data, knowing that when the door is locked, the room is in use. Running wire down through the hollow metal trim was tedious and time consuming, and involved a lot of false starts and fishing around with a straightened coat hanger, but we finally got a run of wire inside each frame.

On each office floor there are two bathrooms side by side, and the pair of switches inside the door jambs are wired to a single Arduino fitted with an Ethernet Shield for network connectivity. The Arduino samples the switches many times per second, providing near-instant feedback.

After debouncing the switch input signal over about 50 milliseconds, the Arduino waits for a definitive change in state – from locked to unlocked, or unlocked to locked – before illuminating LED lights on the wall.

After the light corresponding to the now-occupied bathroom is lit, the Arduino also performs an HTTP POST, sending the event details (floor level, which room, and current occupancy state) to an in-house webserver running Node.js and MongoDB. The webserver records the data and makes it visible on a web page for viewers to check the availability digitally, for those who can’t see the wall mounted lights from their seating position.

If you’d like to employ a project like this, the code we hacked together is available on GitHub, and the wiring is rather straightforward:

All components share a common ground
LED anodes are wired to room_a_led_pin and room_b_led_pin and brought high when doors are locked, and low when unlocked
Switches bring room_a_switch_pin and room_b_switch_pin low when triggered, and the Arduino uses the INPUT_PULLUP pinMode for the unlocked state

Our Hackathon project came in at second place, losing to an as-yet-unannounced software project, but we had a lot of fun staying up and hacking all night!

Adventures with Nest

2013-06-06T22:54:17Z

I recently purchased a pair of Nest Learning Thermostats for my new home. Compared to the white brick style Honeywell thermostats that came with the place, the Nest is so much more advanced. It does temperature learning, auto-away, and remote control over Wi-Fi from the web and iOS devices. It also has a color LCD and just generally looks beautiful on the wall with its brushed stainless steel housing.

Installing the Nest is pretty straightforward with a modern forced air heating and cooling system:

Remove the old thermostat and mounting plate from the wall
Disconnect the wires
Patch and paint any holes
Install the Nest mounting base and connect the wires
Pop the Nest onto the base and configure the software

My initial install went well physically, but not long after, I discovered that the Nest would regularly run out of battery power. I quickly learned that due to how the HVAC circuits are arranged, the Nest can only draw power while the system is running. When the system is not busy heating, cooling, or running the fan, the Nest is left to run under its own battery power. And in sunny California during the springtime, the system doesn’t run often enough to let the Nest keep a charge. Several times per day, I would have to unplug the Nest from its base and charge it over micro USB. Not a great solution.

Reading more about the Nest and HVAC circuitry, I found that there is a solution for situations like this. A “common wire” that provides a path back to the HVAC controller would allow the Nest to draw the power it needs while not running any systems. As luck would have it, my system provided this common wire, but connecting it to the Nest had no effect on the battery. More telling was the fact that the Nest did not detect that the wire was connected.

So, I decided to find out what was at the other end of that common wire. I put up a ladder and ventured into the attic of my home and scouted around the furnace. On top of it, inside an easily-opened metal enclosure, was the thermostat controller, a ZTech ZTE2S. Double checking the wiring diagram and comparing it with the wires on the left (coming from the Nests), it’s clear that the blue common wire is simply not connected to the controller. In the photo below, you can see that it’s clipped short, close to the brown jacket covering the bundle of five wires.

Reconnecting the wire was a matter of disconnecting the wires that were already connected, snipping them all to the same length, and stripping a little plastic off the end so that all five can be connected to the HVAC controller.

A few hours after leaving the Nest installed with the common wire attached and the HVAC controller all closed up, its battery has fully charged and the features work great.

Simulating Slow Internet for iOS Testing

2011-05-13T02:58:35Z

Apple’s iOS Simulator is an acceptable environment for testing development code, but when users purchase your finished app from the App Store, they’ll be running it on real hardware, particularly on networks that are likely much less reliable than your home or office internet.

To ensure your app performs well under real-world conditions, you can load up the code on a device and go outside, but then you can’t debug as easily. And even if you bring your MacBook Air with you, what if your Verizon iPhone is everything you hoped, and it performs admirably on the worst of days? To get around all of this, you can approximate an unreliable network with SpeedLimit. SpeedLimit is a System Preferences pane for intentionally and selectively slowing down specific ports and domains.

Download and install SpeedLimit, add one or more hosts (separated by commas, as seen above), select a target speed, and click Slow Down. Subsequent network requests matching the criteria you set will be throttled, giving you time to go all out testing your app’s performance and error handling. Does it crash when users hit the Back button while a UITableView is loading? Does it lock the UI while downloading avatars or thumbnails? SpeedLimit lets you find out, and be confident in your networking code.

How to Find the Right Windows Driver

2009-09-15T02:32:14Z

When setting up a new Windows machine, whether it’s Windows 2000 all the way up through Windows 7, you’ll occasionally run into an issue where you need drivers for a system or PCI device that you just can’t seem to find. To make matters worse, you don’t know which company made the device, so you don’t even know where to start looking for drivers. Should you go to Dell’s site? The motherboard manufacturer? Persistent “Unknown device” entries in the Windows Device Manager are a plague upon even the most seasoned techs. Here’s a tip to get your driver hunt moving in the right direction.

Find Out Who Made the Device

Figuring out which company made the device(s) in question is the first step towards getting it working. Start by opening the Windows Device Manager. My preferred quick way of doing this is clicking Start, Run, type devmgmt.msc, and pressing Enter. Once there, choose the device in question and right click it, and select Properties. Select the Details tab to see something like the view below:

Note the PCI VEN and DEV 4-character identifiers. PCI, USB, and many other system devices have Vendor and Device IDs. The Vendor ID is specific to the manufacturer, like Broadcom or nVIDIA. The Device ID is specific to the particular make or model of device you have. These are expressed in hexadecimal (0 through 9 plus A through F), so don’t be surprised to see letters there, as well. Some common Vendor IDs are 8080 and 8086 for Intel, 0A5C for Broadcom, 10DE for nVIDIA, 1002 for ATI, and many more.

Look Up Vendor and Device IDs

A common way to express both the Vendor and Device IDs in a single string is 1022:2000, Vendor ID first. Combine your Vendor and Device IDs in this manner, and wrap it with quotes: “1022:2000”. Google that, and you should quickly figure out who made your “Unknown device” and what model it is. With this knowledge, you can either find the appropriate driver on your computer manufacturer’s website (Dell makes a good note of which manufacturer’s devices they use for a particular system), or you can visit the device manufacturer’s website directly.

I hope this information can help those looking to simply get their hardware working under Windows, whether it’s running on a Mac or PC.

MacAlly IceKey USB 2.0

2009-07-05T17:35:02Z

MacAlly has been producing the same IceKey keyboard since 2003, and while it’s a solid performer featuring comfortable low profile scissor keys and extra USB ports, it still ships with a maddeningly slow internal USB 1.1 hub. While this early USB specification is plenty fast for a keyboard alone, it throttles back speeds of all attached devices like flash drives, iPods, and digital cameras. Copying an music album or two can take several minutes over USB 1.1, whereas today’s USB 2.0 takes only seconds. With USB 2.0 as today’s ubiquitous standard and USB 3.0 just around the corner, it’s disappointing that MacAlly has yet to update the IceKey to include a faster hub. Luckily, you can take matters into your own hands. Here’s how to install a high speed hub inside the keyboard while maintaining MacAlly’s elegant factory appearance.

What You’ll Need

a MacAlly IceKey
a small, narrow USB hub (a cheap Targus hub worked fine for me)
a screwdriver set
a soldering iron, solder, and spare wire
a pocket knife (I’m not sure any project I’ve done didn’t require this…)

Open the Hub

USB hubs generally aren’t too complicated to open, and this Targus on is no exception. A single screw on the underside holds together the hub’s two plastic halves, which snap apart with little effort. Write a note or take a picture to document the wire colors and order relevant to the orientation of the board inside – it will come in handy later.

Open the Keyboard

The MacAlly IceKey is slightly trickier to get apart, but not much. Remove all the obvious screws on the bottom of the keyboard, including the one under the “Do Not Remove”/Quality Control/Warranty sticker. Then, flip open the pivoting feet to expose two more screws covered by a protective piece of rubber. The final two screws are under the front rubber feet.

Starting with the keyboard upright and facing you, begin unsnapping the plastic hooks around the perimeter starting at the front middle. A plastic pry tool might come in handy, but isn’t required. Once the top is removed, you can clearly see all the important electronics, including a very common Cypress USB controller chip.

Test Fit Everything

Just to make sure the rest of this modification is physically possible, fit the USB hub board in the open space at the top of the keyboard and set the keyboard bezel on top. Luckily, the IceKey has plenty of room to spare. I was planning to have to remove the USB ports from the hub board to make everything fit, but there was so much extra space that I didn’t even have to go to that length.

Unhook the Keyboard

Carefully pull the keyboard ribbon cables straight away from their matching plugs on the controller board. Gently flip the keyboard pad over, and unscrew the two short ground wires to completely free the keyboard keys from the plastic housing. Set it aside for later; it does not need to be modified – all the action happens on the two remaining circuit boards. Unscrew both boards to get at the backs of each.

Cut Wires

Cut the gray ribbon that leads from the controller board to the left port. Since that wire only provides USB 1.1 speed, we won’t be using it. You’ll note that it has two extra wires that run to an unpopulated LED on the left board, so we can skip those when doing the re-wiring. (I wonder what MacAlly had in store for that, or if this keyboard is a “port” from another language or something?)

Unplug the USB cord from the controller board and cut off the connector. This cord needs to run to the input on the new USB hub, and not to the input on the keyboard controller board where it currently connects.

Cut Traces

Since the right port also needs USB 2.0 speeds, it too will need to be disconnected from its USB 1.1 source. However, it is soldered directly onto the controller board and is effectively hard-wired into the slowness. This is perhaps the trickiest part of the whole project: desolder the USB connector and use a knife to scrape away the traces that run to the port. Some are on top of the board, and some are on the bottom. (You might be able to get away with cutting the traces without removing the port, as a little bit of the traces are exposed on the top before routing into electronic components, but you’ll want to test with a multimeter and make sure you’ve done this successfully.) Once all four traces to the port are cut, re-solder the USB port in place (if you removed it).

Re-wire the Keyboard Controller and Ports

Here’s a simple before and after block diagram to help your wiring layout:

Solder Keyboard Cord to Hub Input

Strip about an inch of plastic from the cut end of the keyboard cord to expose its individual wires, and strip just a millimeter or two from each of those. Using your note from earlier, solder the keyboard wires to the matching USB hub input connections. On this Targus hub, the wires were in the same order as the standard USB pinout.

Solder Keyboard Controller to a Hub Port

Solder four wires from the keyboard input port (where the cord originally connected to) to one of the USB hub ports, effectively making the keyboard controller into one of four devices on the hub. Previously, the keyboard supplied its own hub, but we’re bypassing it altogether. Luckily, most everything is either color coded or silkscreen labeled on the circuit boards (V/5V is red, D- is green, D+ is white, and G/GND is black).

Solder Keyboard USB Ports to Hub Ports

Solder wire from the left USB port board to another free USB hub port, making sure to get the order correct. With the traces cut on the right port, run wire from the connections under the board to yet another free hub port. You should end up with a hub layout like this:

Test and Close It Up

With each new component wired up, double-check your connections and plug it in. Initially, my first test failed and Windows complained about a malfunctioning USB device (I tested it on an old PC, just in case I shorted out the computer’s USB controller. I’d rather fry an old computer than my new iMac!) The key to making everything work properly was to reconnect those two shared ground wires from early on – the keyboard must have a common ground with the controller and hub!

Once it works, secure all the wires and boards. I used a few short pieces of electrical tape to stop everything from bouncing around, too. Snap the plastic top back on, replace all the screws, and enjoy your USB 2.0 MacAlly IceKey!

Boot Camp Drivers for iMac (Early 2009)

2009-06-14T20:16:52Z

Apple’s newest iMacs are a fast set of machines and run Windows faster than any PC I’ve ever used, but unfortunately, Apple has yet to update Boot Camp with the required drivers to support the latest and greatest components. Mac OS X ships with the necessary software and works as expected, but Windows XP is met with some trouble. Right away, you’ll notice that your graphics resolution is set to a paltry 800x600, and you have no sound output as well. Here’s how to get those systems working until Apple can provide an “official” fix:

Graphics Drivers

Visit nVidia and download the “GeForce 9M Series (Notebooks)” driver package, as this is graphics chipset in the Early 2009 iMacs. Run the downloaded setup utility, next-next-nexting your way through the steps, and reboot at the end when prompted. Upon restart, you’ll be able to properly max out your display to the iMac’s native resolution.

Audio Drivers

Boot Camp 2.1 actually ships with RealTek HD audio drivers, as evidenced by the lack of a yellow exclamation mark for this system in Windows’ Device Manager, but they don’t seem to work properly, since there’s no sound output. Visit RealTek and download the “High Definition Audio Codecs” driver package for your OS. In this instance, I downloaded “Windows 2000, Windows XP/2003(32/64 bits) Driver only (Executable file)”, since I’m running Windows XP Pro SP2. Run this setup utility as well, rebooting again when done. After restarting, you should be greeted with Windows’ standard login sound, confirming the install worked.

Update: The Mac OS X 10.6 Snow Leopard disc includes Boot Camp drivers for these iMacs. The Snow Leopard disc is a hybrid image: it provides the Mac OS X installer when viewed under a Mac OS X system, but shows Windows drivers when viewed in Windows. Just run the setup in Windows right off the disc, and you should be set.

Dig into iPhone Apps

2009-03-23T05:36:17Z

So you’re curious about the contents of iPhone and iPod Touch apps, including artwork, sounds, and more? Here’s how to dig into an application and see what goodies are hidden inside. Standard copyrights still apply.

Sync Your Apps with iTunes

Assuming you already have the target application on your iPhone or iPod Touch (just “iPhone” from this point forward for brevity’s sake), simply sync your iPhone with your Mac or PC. Doing so will backup your device and transfer any purchased applications in both directions. With the target application now on your computer, navigate to your iTunes “Mobile Applications” folder, where iTunes typically does its own file housekeeping. Under Mac OS X, the default location is /Users/yourname/Music/iTunes/Mobile Applications/.

Unzip an App

Copy your target .ipa-suffixed application to a different location, ensuring that the original stays in the Mobile Applications folder to keep iTunes happy. To get inside the application, rename its extension to .zip. Open the zip file, and you will have access to the guts of the app (except the source code, of course).

High-res App Artwork

Directly inside the unzipped application folder, you’ll find a file named iTunesArtwork, with no extension. A hex editor revealed that the file is typically a jpeg image, so rename it to include .jpg at the end, and you’ll end up with the same 512x512 pixel artwork displayed by iTunes when browsing downloaded Applications. To get at other resources, open up the adjacent “Payload” folder, and you’ll find a .app file – the application bundle that runs on the iPhone. Right- or Control-click on the .app, and choose “Show Package Contents” to open up the bundle.

Sounds

Sounds are typically found among the many resources directly inside the application as files with extensions like .caf, .mp3, .aif, and .m4a. At this point, the organizational structure is up to the application’s developer, so you may need to look around a little. Leopard’s QuickLook feature is a boon in times like this, helping assess a file’s purpose without opening half a dozen applications.

Other Graphics

Also nestled inside iPhone applications are many of the graphics used throughout the app. It’s possible that some may be drawn by code, but complex graphics are generally stored as images. However, viewing the images isn’t as easy as renaming the files as before. This will be a bit trickier, as the iPhone works some magic on the images before finishing the app build process, leaving images in an iPhone-optimized state. Fortunately, the process can be reversed with a little bit of Terminal trickery:

Copy all .png images to a new folder elsewhere. Images of other formats (.jpg, .gif, etc.) should be readily viewable.
Download David Watanabe’s modified iPhonePNG command-line application, unzip the archive, and open up Terminal from your /Applications/Utilities folder.
Type cd, then drop the iPhonePNG folder into the Terminal, and tap Return to switch to that folder.
Type ./iPhonePNG, drop the folder of encoded images into the Terminal, and tap Return to decode the whole folder full of images.
The output folder sites beside iPhonePNG, so type open . and tap Return (open space dot) to open the current folder (a dot, in Unix terms) in the Finder. Open the decoded images folder and have a look around!

iPod Screen Scratch Removal Revisited

2009-01-07T02:35:59Z

Several years ago, I recommended RadTech’s IceCreme as a great solution for cleaning up your iPod’s scratched-up screen. While I still stand by my results and recommendation, IceCreme isn’t the sort of thing you can find at a nearby store, and is also a little pricey. Removing scratches from iPods and other pocket-bound electronics remains a common problem, so I thought it would be worthwhile to test some of the other available options. Additionally, since nicks and scratches occur on more than just the screen, we’ll also test the solutions elsewhere on an iPod. For this little experiment, I chose three solutions offering varying levels of abrasiveness: Colgate toothpaste, Brasso metal polish, and Easy-Off oven cleaner. All three promise to leave their intended surfaces shiny and clean, and in the case of the latter two, free of scratches. We’ll see how each fares when put to use on both the front plastic and back metal of an iPod.

To keep things clear, each polish will be used in a masked-off area, hopefully leaving a clear division among the results. The target iPod is an already well-used 4G 20GB iPod, with most of its still working inner parts removed and replaced with padding just to help sustain its form while being polished. Donated to the cause, this iPod will be beat up even further, with even layers of light scratches, heavy scratches, and deep cuts, simluating everything from normal wear to keychain induced destruction. It has surely seen better days, and is now destined for that great Apple Store in the sky, all in the name of science. I started with Brasso first, since it has been recommended many times since my last scratch removal post, both by commenters and firsthand accounts. If you’re attempting this yourself, be sure to work in a well ventilated area, as Brasso smells very strongly of ammonia, and might start to irritate your eyes after a short while!

After only five minutes of polishing, the results were quite good, with nearly all of the light and medium scratches completely removed from the screen area. Deeper cuts remained, though their rough edges were significantly smoother.

Toothpaste was next on the list, and while it left the iPod minty fresh with a sparkling shine, its scratch-reducing effects were barely noticeable. Due to its sticky consistency, it was also more difficult to polish with than the more liquid Brasso, yielding poorer results for double the effort – a total flop. Oven cleaner was last, and I really had no idea what to expect with it. Claiming to leave glassy surfaces shiny and free of scratches, it sounded like a possible winner. As it turns out, it’s not much more than a repackaged kitchen cleaner, resulting in a streak-free but still heavily scratched iPod. I’ll end up cleaning my glass top oven with this one, and nothing else. With the front of the iPod clearly showing Brasso as the top choice, it was time to see what worked best on the scratched metal backing of the iPod.

Again, after just a few minutes with each polish, Brasso came out on top, while the other two trailed woefully behind. The Brasso-polished back still had quite a few scratches, though far less pronounced than when I started. All of them, including the deep cuts, had a very slick feel, whereas the others still left the surface pretty rough.

Convinced that Brasso was the right choice, I went back and finished off the front, cleaning up all but the most severe marks on the screen.

Given the results of my tests, I can easily recommend Brasso as a great iPod polishing solution that can be had for under $3 at your local stores.

Learning Cocoa for the iPhone

2008-12-21T22:50:26Z

These last few weeks, I’ve been teaching myself Cocoa to learn what makes Mac OS X and iPhone OS apps tick. While Objective-C is quite a departure from my usual web development world, it has quickly become one of my favorite languages, as it takes care of much of the drudgery of pure C and has plenty of useful frameworks to get your application up and running quickly. Here are some of the best resources I’ve found so far:

Cocoa Dev Central and Become an Xcoder are both excellent tutorials for beginners, written in a clear, straightforward manner. They also explain the ins and outs of memory management, which is critical on platforms like the iPhone and iPod touch.
Stanford’s CS193P lecture notes and examples have proven to be one of the best resources for learning Cocoa, particularly for the iPhone. These notes and tests offer Cocoa Touch in bite-size chunks, with a little bit of “on your own” work to ensure you know your stuff before moving on.
Google Code Search is a good last resort for examples of how others are using a small bit of code or a particular class. For more accurate results, append “lang:objectivec” to your search string to narrow results to only Objective-C code.

Consolas Cursor Fix

2008-12-16T19:35:08Z

If you’ve attempted to use Consolas as your choice programming font on the Mac, you may have noticed (as I did) an odd issue with the font, where your blinking cursor hangs much lower than the current line. Oddly enough, this little issue only seems to affect Mac OS X. Even the Consolas set that ships with Microsoft Office 2008 has the same problem! Yet, when the same exact font file is used under Windows, the cursor position is correct.

John Gruber mentioned that BBEdit 9.1 now ships with Consolas as its default font, so I decided to see if it had the same cursor problem I had experienced in the past. As it turns out, BBEdit’s version of Consolas works just fine, as seen in the image above. However, it doesn’t include the other styles like Consolas Bold, Italic, and Bold Italic.

Through one way or another, the copy of Consolas that ships with BBEdit 9.1 is different than the one that ships with Microsoft Office 2008. To make system-wide use of the working version, download BBEdit 9.1, mount the disk image, and navigate to:

(Control-click BBEdit, and choose “Show Package Contents” to get inside the application bundle): BBEdit.app/Contents/Resources/Fonts/consola.ttf

Copy consola.ttf from BBEdit’s “Fonts” folder to your own Fonts folder at ~/Library/Fonts, or /Library/Fonts if you want to make it available to everyone who has an account on your computer. Then, fire up your favorite editor, set Consolas as your preferred fixed-width font, and get coding!

Update: Bare Bones has apparently changed the version of Consolas that ships with BBEdit versions later than 9.1, and they now have the cursor problem as well…