Inspira

The Problem: A Calculator That Doesn't Exist

If you spend any time in the HP calculator community, you eventually arrive at the same frustrating conclusion: the perfect calculator has never been made. Not all at once, anyway.

The HP Voyager series — the 11C, 12C, 15C, and their siblings — got the form factor right. Landscape orientation. The golden ratio between length and width. Something about the proportions just works in the hand, and decades later no one has meaningfully improved on it.

But the Voyagers came with small, single-line displays. The later calculators that added multi-line graphical displays — the HP 48, 49, 50 series, and more recently the HP Prime — gave up the elegant proportions. And the HP Prime's display, while capable, is honestly a bit of a letdown aesthetically for a flagship device in this day and age.

So you end up wanting something that doesn't exist: the body of a Voyager, the display of a modern graphing calculator, and the look and feel that made the originals iconic.

There's only one solution. Build it yourself.

The Design: Staying True to the Voyager DNA

The starting point was clear — landscape orientation, golden ratio proportions, RPN operation. Everything else followed from there.

The display choice drove most of the other decisions. I opted for a 240 × 960 pixel bar-type color display with 18-bit color — a tall, narrow panel that sits beautifully in landscape orientation and gives genuine graphical capability without abandoning the slim profile. It's a striking display, and it should look nothing like the HP Prime.

To accommodate the display width, the keyboard needed one additional column of keys compared to a standard Voyager layout, adding about 17 mm to the width. To preserve the golden ratio, the height grew by a corresponding amount. The overall device ends up only a few millimetres larger than the original Voyagers — still very much a pocketable calculator.

I considered capacitive touch for the soft key row but ruled it out — it adds too much thickness to the bezel and complicates the housing. Instead, a row of physical soft keys runs along the top, tied to the display. The shift and function keys as well as the power button in that row.

The full keyboard matrix is 11 × 5, giving a good complement of dedicated keys without cluttering the face. The whole thing is housed in CNC-machined aluminium, which is the only material that will give the keys and body the weight and feel the HP originals are remembered for.

Hardware Specification

The accelerometer is there primarily for power management — a colour display draws meaningfully more current than the segment display of an original Voyager, so detecting when the calculator is set down and dimming or sleeping the display will matter for battery life.

The Hard Part: Software

I'm a hardware engineer by profession and by hobby. Software is ... different.

Getting a beautiful piece of aluminium with a glowing display to actually behave like an HP calculator is a significant undertaking. The good news is that the hardware is well-suited to it — the STM32U599 is a capable microcontroller and there's no shortage of flash. The question is what to build on top of it.

Here are the options I'm considering:

Option 1: Write It From Scratch in C/C++

The purist approach. Full control over every aspect of the RPN engine, display rendering, and key handling. The upside is that it can be made to feel exactly right — tight, responsive, and true to the HP tradition. The downside is that it's an enormous amount of work, especially for someone who doesn't live in software.

Suitable tools: STM32CubeIDE or VS Code with the ARM GCC toolchain. LVGL is worth a look for the display layer — it's a mature embedded GUI library with good STM32 support and would handle font rendering and basic widgets.

Option 2: Port an Existing RPN Engine

Projects like Free42 (a faithful HP-42S simulator) and WP43 (targeting the HP-43S) are open source and have already done the hard work on the RPN engine and key mapping. Porting one of these to bare-metal STM32 is a very real option — the display dimensions and resolution would need adjustment, but the core logic is proven. This is probably the most practical path to a working, trustworthy calculator.

Option 3: MicroPython or CircuitPython

Running a Python interpreter on the STM32U599 is feasible, and it would make the software layer much more approachable. The tradeoff is performance and the "feel" — MicroPython adds latency that can make a calculator feel sluggish, and the HP aesthetic is partly about instantaneous response. Worth considering for prototyping and experimentation, but probably not the final target.

Option 4: Lua or a Lightweight Scripting Runtime

A small embedded Lua runtime (e.g. eLua) gives a scripting layer with lower overhead than Python. This could work well as a user-facing extension language even if the core RPN engine is written in C.

My current thinking is to start with a Free42 or WP43 port for the calculator core, with LVGL for display management, and add a scripting layer later if there's appetite for user-programmable functionality. But I'm genuinely open to input from the community here — this is the part of the project where I'll benefit most from experience I don't yet have.

A Second Variant: The Digital Dice Roller

Parallel to the calculator project, I'm planning a second firmware variant aimed at a completely different use case: tabletop roleplaying.

Anyone who has played D&D, Pathfinder, or similar games knows the pain of complex dice expressions — rolling "20d6 + 2d8 + 4" by hand takes time, and keeping track of what you've rolled is error-prone. A dedicated device that handles arbitrary dice notation natively, with a beautiful display to show results and history, and physical keys that can be mapped to common rolls, would be genuinely useful.

The hardware is actually very well suited to this. The tall colour display can show roll history, individual die results, and totals at a glance. The soft key row maps naturally to saved roll presets. The speaker can do something satisfying when you roll a natural 20.

The dice firmware will be a separate project once the calculator bring-up is stable — same hardware, different personality.