My dad worked for HP from the mid-1970s through the mid-1990s. Needless to say, I used HP calculators in high school and college. The best things about having an HP calculator were the solid physical construction (the buttons on the 11C and 15C were awesome), the accuracy, and the fact that whenever your classmates asked to borrow your calculator they would recoil in horror when you asked them whether they knew RPN. Nobody borrowed my calculator. Anyway, I love this project.

If the CPU is nibble-oriented, wouldn't that mean that that is its byte size?

The core question: how did HP's scientific calculators actually work at the gate level? That rabbit hole led to building one from scratch.

The architectural decision everything else follows from: a decimal calculator should store numbers as BCD — one decimal digit per 4-bit nibble. A standard byte-oriented CPU (Z80, 6502) fights that layout constantly. So I designed a small custom CPU in Verilog where 4 bits is the natural data width and memory is nibble addressable.

What the project covers:

- Custom CPU: Harvard architecture, 12-bit ISA, 8-state execution FSM, hardware stack guard with a FAULT state for microcode debugging

- CORDIC for trig functions, verified to 14 significant digits

- Two-pass assembler in Python (~700 lines)

- Verilator + Qt framework: same Verilog source runs in simulation, as a desktop GUI debugger, as WebAssembly, and on real hardware

- Scripting language on top of the microcode for adding functions without touching hardware

- Custom PCB (EasyEDA/JLCPCB), battery, charging circuit

Write-up: https://baltazarstudios.com

Hackaday: https://hackaday.com/2026/05/13/build-the-cpu-then-build-the...

The core question: how did HP's scientific calculators actually work at the gate level? That rabbit hole led to building one from scratch.

What the project covers:

- Custom CPU: Harvard architecture, 12-bit ISA, 8-state execution FSM, hardware stack guard with a FAULT state for microcode debugging

- CORDIC for trig functions, verified to 14 significant digits

- Two-pass assembler in Python (~700 lines)

- Verilator + Qt framework: same Verilog source runs in simulation, as a desktop GUI debugger, as WebAssembly, and on real hardware

- Scripting language on top of the microcode for adding functions without touching hardware

- Custom PCB (EasyEDA/JLCPCB), battery, charging circuit

Write-up: https://baltazarstudios.com

Hackaday: https://hackaday.com/2026/05/13/build-the-cpu-then-build-the...

Very impressive, and obviously a labour of love! As a calculator and SystemVerilog enthusiast, it's wonderful to see a project such as this come to fruition - congratulations!

I'm holding in my hand a 4-bit Von Neumann Mostek MK50310N that my father and I used to use to build calculators long ago. Although Mostek made chips for HP (such as the HP-35), they weren't commercially available, but the 50310 was. We could only dream of a project such as yours. I was happy when the "open source" NumWorks was released, but this project aligns more with my interests.

Will definitely install the Qt simulator - would be even better to build one IRL!

At least the 6502 has a BCD mode built in!

Ironically the Z80 is a nibble ALU. That's why its so slow compared to the competition, an 8 bit add on a "2 MHz" Z80 takes as much clock time as a 8 bit add on a "1 MHz" 6809.

My biggest challenge the first time I ever used an HP calculator was less RPN than the syntax of it. I thought I had to hit enter after every token so I typed, e.g., 2⎆3⎆+⎆ rather than 2⎆3+. Needless to say, this did not work as expected, but being simultaneously vain and bashful, I was unwilling to ask for help and did almost all the arithmetic for my freshman physics class by hand.

> the buttons on the 11C and 15C were awesome

What is the trick to engineering HP calculator keys? Nobody gets keys right like the old HP calculators.

In this age of 3D printing and fast prototypes, we really ought to be able to crack this.

I still have my dads old HP with the glowing red letters and all the functions. Not sure if we still have the charger. Not sure the battery is any good, but the calculator worked fine last time it was turned on decades ago. Any idea if this can be made to function again?

"Can I borrow your calculator"

"Sure!" (hands over HP-25C)

"Hey, where's the equals key?"

If the CPU is nibble-oriented, wouldn't that mean that that is its byte size?

It's actually "nybble."

Are you trying to make a pun with byte/bite relating to nibble? Because that's actually where the term nibble (referring to 4 bits) comes from, so I'm not sure such a pun even counts as a pun anymore. Or am I misinterpreting your comment?

A byte is always 8 bits. The word you're looking for is `word-size` which, in this case would be 4 bits.

> the buttons on the 11C and 15C were awesome

What is the trick to engineering HP calculator keys? Nobody gets keys right like the old HP calculators.

In this age of 3D printing and fast prototypes, we really ought to be able to crack this.

At least the 6502 has a BCD mode built in!

The Z80 does have a DAA (decimal adjust arithmetic) instruction to facilitate BCD arithmetic. I don't think I ever used it in my Z80 years and I'm not familiar with the details. Sadly I have much less experience with the 6502, I didn't even know it had a BCD mode.

I'd like to amplify this. Decimal math using nibbles containing 0 through 9 was standard operating procedure, one of the things that made the 6502 nice. Unfortunately you had to use a short loop to convert between 2s complement and BCD.

Very impressive, and obviously a labour of love! As a calculator and SystemVerilog enthusiast, it's wonderful to see a project such as this come to fruition - congratulations!

Will definitely install the Qt simulator - would be even better to build one IRL!

Re Numworks, at $125 for a calculator, you've got to really love the idea.

It's actually "nybble."

When did we stop spelling it "nybble"?

"Can I borrow your calculator"

"Sure!" (hands over HP-25C)

"Hey, where's the equals key?"

From Gates to a Calculator

This project implements a fully functional scientific calculator in hardware using an FPGA. It includes a custom soft CPU, microcode firmware, and supporting tools.

For the full story, see the blog.

Try it in a web browser:

screenshot

Project Structure

Folder	Description
`verilog/`	SystemVerilog source files for the CPU, ALU, I/O, and test benches
`ucode/`	Microcode (firmware) for the soft CPU
`quartus/`	Quartus project files for FPGA synthesis
`modelsim/`	ModelSim simulation setup
`Qt/`	Qt-based simulator and debugger (uses Verilator)
`calctest/`	Command-line test harness for hardware verification (uses Verilator)
`tools/`	Assembler and script compiler for the microcode
`Pathfinding/`	Algorithm research and verification projects

Quick Start

The fastest way to try the calculator is to build the Qt simulator:

# From WSL2
cd /mnt/c/Projects/FPGA-Calculator/verilog
make qt

Then open Qt/Calculator.pro in Qt Creator and build for "Desktop Qt MSVC2022 64 Bit".

See the verilog/ and Qt/ folders for detailed instructions.

Required Tools

Install these tools depending on your target:

Tool	Purpose	Notes
Verilator	Verilog simulation	Required for Qt simulator
Qt	Desktop/WebAssembly/Android app	Version 6.9+
Quartus	FPGA synthesis	Version 13.0 SP1 for Cyclone II
ModelSim	Waveform simulation	Optional
Visual Studio 2022	C++ compiler for Qt	Community Edition
Python 3	Assembler and tools

Verilator Setup

Verilator runs in WSL2 (Windows Subsystem for Linux). The project source files reside on a Windows partition and are accessed from WSL2.

Target	Verilator Version	Notes
Desktop (Qt/MSVC)	5.x (latest)	Recommended
WebAssembly	4.228	Required (no thread support)

# Install prerequisites
sudo apt-get install build-essential autoconf flex libfl-dev bison

# Clone and build Verilator
git clone https://github.com/verilator/verilator
cd verilator
git checkout v5.042    # For Desktop, or v4.228 for WebAssembly
autoconf
./configure
make -j8
make test

# Set environment (add to .bashrc for persistence)
export VERILATOR_ROOT=$(pwd)

Optionally install GtkWave for viewing waveforms:

sudo apt install gtkwave

Build Targets

Target	Command	Description
Qt Simulator	`make qt` in `verilog/`	Build for Qt desktop application
Calctest	`make calctest` in `verilog/`, then `make` in `calctest/`	Command-line test harness
ModelSim	`make test_self` in `verilog/`	CPU self-test for ModelSim
FPGA Hardware	`make revB` in `verilog/`	Assemble microcode for RevB board

See the README files in each subfolder for detailed build instructions:

verilog/README.md - Verilator simulation and microcode assembly
calctest/README.md - Command-line test harness for hardware verification
quartus/README.md - FPGA synthesis and programming
ucode/README.md - Microcode source files

Pathfinding Projects

Independent research and verification projects:

Folder	Description
`Pathfinding/Proto/`	BCD arithmetic golden reference for hardware verification (submodule)
`Pathfinding/Proof/`	Proofs of concept for complex operations using basic arithmetic
`Pathfinding/Methods/`	C++ implementations of calculator algorithms (deprecated)
`Pathfinding/Input/`	Numerical input state machine simulation
`Pathfinding/Mockup/`	Keyboard layout design and user interaction testing

License

This project is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License.

You are free to:

Share - copy and redistribute the material in any medium or format
Adapt - remix, transform, and build upon the material

Under the following terms:

Attribution - You must give appropriate credit and indicate if changes were made
NonCommercial - You may not use the material for commercial purposes
ShareAlike - Contributions must be distributed under the same license

A byte is always 8 bits. The word you're looking for is `word-size` which, in this case would be 4 bits.

A byte is not always 8 bits on old machines, though it is standardised as 8 bits nowadays.

This is why network RFCs talk of "octets", to avoid the ambiguity. Octets are always 8 bits.

https://en.wikipedia.org/wiki/Octet_(computing)

I think you might be missing the attempt at humor.

Re Numworks, at $125 for a calculator, you've got to really love the idea.

When did we stop spelling it "nybble"?

I didn't think it was that much, but I checked my receipt from 2017, and sure enough it was!

I have in my hand (I guess I like using that phase today), my father's original receipt for the HP-45 (it's with the box and manual). $299.00 in 1975, which is $1,850 today(!!!).

Relatively speaking, electronics are very, very cheap today compared to what they used to be. Still appreciate that my $30 CASIO does 90% of that the NumWorks can do, but I'm happy to support upstarts such as NumWorks.

"Nibble" may well have always been in use by folks, and nybble may have actually come later. At the very least, references to each spelling being in use exist for the last ~60 years.

The first book match I get for "nibble" near "byte" is in the 1964 "System 360 Assembler Language" by Don H. Stabley uses nibble. The earliest match I can find for "nybble" in relation to computers was the 1968 "Encyclopedia of library and information science". Nybble (and likely nibble) itself doesn't seem to have taken off until around the mid 1970s https://books.google.com/ngrams/graph?content=nybble&year_st...

References to the coining of the term in 1958 of course don't provide a textual source.

I was wondering this as well. Probably when a new wave of people discovered the concept in the absence of the older wave? By contrast, "byte" has been in use continuously and widely.

A byte is not always 8 bits on old machines, though it is standardised as 8 bits nowadays.

This is why network RFCs talk of "octets", to avoid the ambiguity. Octets are always 8 bits.

https://en.wikipedia.org/wiki/Octet_(computing)

I didn't realize that there was a 16 bit name called a 'chomp' haha. But more formally hextet.

The definition of a byte today is different than the definition of byte when those machines were manufactured. Just like how 'foot' is now standardized(*)

(* technically, a 'foot' is not a standard unit of measure but that's due to the long history of 'foot' not being standardized until relatively recently)

I didn't think it was that much, but I checked my receipt from 2017, and sure enough it was!

I have in my hand (I guess I like using that phase today), my father's original receipt for the HP-45 (it's with the box and manual). $299.00 in 1975, which is $1,850 today(!!!).

"Nibble" may well have always been in use by folks, and nybble may have actually come later. At the very least, references to each spelling being in use exist for the last ~60 years.

References to the coining of the term in 1958 of course don't provide a textual source.

I was wondering this as well. Probably when a new wave of people discovered the concept in the absence of the older wave? By contrast, "byte" has been in use continuously and widely.

I think you might be missing the attempt at humor.

I didn't realize that there was a 16 bit name called a 'chomp' haha. But more formally hextet.

The definition of a byte today is different than the definition of byte when those machines were manufactured. Just like how 'foot' is now standardized(*)

(* technically, a 'foot' is not a standard unit of measure but that's due to the long history of 'foot' not being standardized until relatively recently)

No. 8 bit bytes are the de facto standard but that is in no way official nor the definition of the word. You can find modern niche projects with non-8-bit bytes (and by extension non-32 or 64 bit words).

Hacker Times

Hacker Times

I designed a nibble-oriented CPU in Verilog to build a scientific calculator

Discussion

Discussion

From Gates to a Calculator

Project Structure

Quick Start

Required Tools

Verilator Setup

Build Targets

Pathfinding Projects

License