SwissMicros DM42n
The DM42n is SwissMicros's high-end RPN calculator, faithful to the legendary HP-42S it pays homage to, while upgrading it with modern connectivity and oodles of speed. Handmade by a small Swiss team, it's a labor of love — and it shows in every little detail. Sure, it's expensive, but to the right person, it's a small piece to pay for one of the finest calculators, if not the finest, currently available.
Pros
- It's an HP-42S at its core. Enough said.
- Top-notch build quality
- Best screen you'll see on a calculator
- Tastefully and unobtrusively modernized
- Unmatched 34-digit precision
- Supports custom firmware
Cons
- Expensive
We find it really hard to even be near the SwissMicros DM42n without smiling like absolute sillies. It’s a team of four’s carefully-crafted love letter to legendary calculators of the old, honoring and cherishing their ever-present heritage. But it’s oh-so-bittersweet: a piece of the 80s, anachronistically created in the now, built to last and be loved for decades. When did these qualities fall out of fashion?
There was a time, not terribly long ago, when calculators were king. There wasn’t much else that could fit in a shirt pocket, compute and store things and run user programs. And HP was king among calculators, with trailblazers like the HP-65 and the HP-41C paving the way for what one day would become PDAs and later, smartphones. But our DM42n gets its name and soul from another, later HP model; one that’s often regarded as the finest RPN calculator ever made (actually, scratch that — many consider it the finest calculator ever): the legendary HP-42S.
But what’s an RPN calculator? Almost all modern calculators, from basic office 4-bangers to dedicated scientific and graphing handhelds, and even the built-in calculator apps that ship with many OSs, use algebraic input (mostly) based on infix notation. RPN calculators, on the other hand, short for reverse polish notation, exclusively use postfix notation — with operators following their operands. Almost all HP calculator models made in the 70s and 80s utilized RPN, as well as a number of models from other manufacturers, though the former remain by far the most recognizable of the kind.
While all-RPN models are all but extinct, some vestigial remains of postfix notation remain even in algebraic systems. Simple single-step calculators still use it for any unary operators they might have — things like square roots, powers and trigonometric functions that fire immediately after their corresponding key gets pressed. Modern, higher-end scientific and graphing models come with full-featured expression editors capable of rendering things just as they’d appear on paper, shifting away from any postfix-based input. It’s the end of an era, at least in the mainstream.
But there’s a reason that RPN still has a loyal following among calculator aficionados: it can be a better input method for those acquainted with it. The reasoning here is not as straightforward and there are several schools of thought, but it often boils down to the number of keystrokes required to complete a calculation, and the immediacy of the stack-based approach. We won’t delve into too much detail right now, but will cover the benefits, as well as some lovely features unique to the DM42n (and, accordingly, the HP-42S) that make using it a joy.
The company behind the DM42n, SwissMicros, began their journey in 2011, making their debut with the DM15C, a credit-card–sized replica of the HP-15C. On a mission to resurrect more of HP’s fabled RPN calculators, the company went on to recreate almost every member of the Voyager series (both in the aforementioned credit-card but also full-size formats), as well as the HP-32SII, HP-41CX and, naturally, the HP-42S. The DM42n is not the company’s first go at the HP-42S, but an upgraded version of the original DM42. Though visually (and functionally) almost identical, these sport different guts. The DM42n also ditches Micro-USB in favor of USB-C for more future-proof connectivity. A lot of what will be said in this review will apply to both, and though both are still available, we’d nudge everyone towards the newer model given the very minor 10 CHF (~$12.5) bump in price.
With HP effectively killing off its calculator division, their last original product being 2013’s HP Prime, it’s likely that we won’t be seeing any more designs from the giant (the rights to create HP-branded calculators got sold off to Moravia Consulting, with most new models made by Kinpo, a chinese ODM company). While the HP Prime is a gorgeous (graphing) calculator in its own right, its half-baked RPN support (despite being the last of its kind) and education-oriented feature set left many old-school HP fans underwhelmed. And apart from the HP Prime and SwissMicros’ offerings, there’s no other RPN option on the market (if you’re gonna count the Prime as one).
Before we continue, we’d like to thank the team at SwissMicros for sending in a review unit of the DM42n. Nevertheless, all opinions stated are own and no third party had any say in the making of this article.
DM42n: first impressions
The DM42n comes in a simple bit of packaging that double a postage box — though this shouldn’t deceive you. The second you flip the lid open you’re greeted by a tastefully designed interior, with several bits of cardboard and paper concealing the calculator, itself safely tucked into a high-quality, microfiber-lined faux leather pouch (akin to those HP calculators used to come in). It’s a premium-feeling unboxing experience for sure — one fitting for such a premium-feeling device.
And, gosh, the DM42n feels like a solid chunk of metal. While not overly heavy due to its overall slim profile, the unapologetic powder-coated steel backplate gives the whole thing so much structural integrity. The spacious and incredibly high-contrast 400 x 240 LCD immediately stands out — it’s a memory LCD, meaning that it’s capable of retaining its last-displayed contents for a long time while needing next to no power to do so. Yes — this means that the the calculator hops out of the box beaming one of its awesome little screensaver images at you, which is charming, to say the least.
We’d like to take a breather and appreciate just how absolutely gorgeous the display on the DM42n is. These little panels are made by Sharp and are some of the best monochromatic (that is, 1-bit) LCDs on the market. They’re extremely legible under a wide range of lighting conditions, look really smooth thanks to tightly-packed pixels with no visible gaps between and — we’ve said this already — genuinely impressive contrast, especially for a reflective LCD panel. (Well, SwissMicros’s website says it’s transflective, but does this matter given that there’s no backlight?) Memory LCDs also quite a bit more energy-efficient than standard ones, requiring noticeable amounts of power only when updating the image, much like e-ink displays. In a way, these are a stopgap technology of sorts, positioned between LCD and e-ink panels, with the latter being even more energy efficient, yet trading off refresh speed for it. For a device like the DM42n, a lower refresh rate screen would have dampened the user experience quite a bit — sticking with LCD tech was a good call.
We don’t know about you, but when we’re faced with a device that has a bunch of clicky little buttons, we like to go all click-click-click on it. It didn’t take us long to indulge a little. The keys on the DM42n feel really solid, with the recognizable beveled front and hinged action, perhaps a tad sharper and more percussive-sounding than those on original HP models. Using the DM42n is a reassuring experience: there’s no second-guessing as to whether a click registered or not. (You’d be surprised to hear that some of HP’s own modern ‘outsourced’ calculator designs utterly fail at this — there was a time when the company’s keyboards were second to none…)
It’s really isn’t too common of an occurrence that a device immediately impresses us, especially as we usually try to suspend any judgement before we’ve dug a bit deeper. But, gosh, it’s hard not to get excited about what SwissMicros has done here — the presentation, build quality and design are all spot-on, and it’s strikingly obvious that a lot of care has been poured into making the DM42n happen.
A closer look at the DM42n
HP introduced the HP-42S in 1988 as a more streamlined, modernized version of the, by that time, aging HP-41C series, while retaining full code compatibility. The latter, while designed with a relatively limited base set of functions, boasted impressive IO, with four expansion module slots, each able to hold a ROM-based ‘application pac’ pre-loaded with programs, additional memory, or connect to hardware accessories. HP produced quite a few, too: thermal printers, plotters, magnetic card readers, barcode scanners, etc. Perhaps the most impressive was the HP-IL module — the Interface Loop — which equipped the HP-41C with a pair of HP-IL ports, enabling users to connect to a wide variety of external peripherals: cassette and disk drives, modems, GPIO interfaces and even 32- and 80-column video interfaces. In many ways, the HP-41C was more like a computer than a calculator.
The HP-42S… didn’t have any of that (save for a single IR diode for communication with a thermal printer accessory) — though it did integrate many of the programs available on the application pacs, including built-in support for numeric integration, complex numbers, matrices, and base-n calculations. All of these were notably absent on the HP-41C. Paired with a lower price tag, a faster processor, more memory, and a much nicer dot-matrix LCD, the HP-42S offered incredible value and a better overall calculator experience, though the inability to easily share programs and stored data (the only effective method was punching things in manually) and connect accessories significantly diminished the tool’s appeal as a handheld, general-purpose personal computing device.
The DM42n bridges the gap by providing the HP-42S with a much-needed USB-C data port, enabling fast program transfers to and from a PC, as well as system backups. This functionality isn’t meant to emulate the HP-41C (remember, SwissMicros makes a much more accurate DM41X for those wanting to relive the glory days), but is simply a reasonable, modern quality-of-life improvement that just so happens to alleviate one of the HP-42S’s key drawbacks. SwissMicros’ own DMCP operating system — short for DM Calculator Platform — handles these transfers in a very user-friendly way and seamlessly integrates the calculator’s hardware with Free42, which provides the actual HP-42S feature set and is the core application running on the DM42n.
Oh, and the DM42n also retains the original’s IR capabilities, ensuring compatibility with old first-party printer hardware. Since we don’t have one of these on hand, we can’t test this feature out, but it’s a pretty neat inclusion either way.
The USB-C port isn’t the only new thing around — the DM42n has all-new internals, trading the classic HP Saturn CPU for a modern STM32U575RI MCU, based on an ARM Cortex-M33 core running at up to 160 MHz. The chip is paired with 64 MB of additional flash memory (additional, as there’s 2 MB of flash, as well as 786 KB of SRAM built into the MCU itself). While this might not seem like that much, it packs a lot more punch than the original HP-42S — and the older DM42, too. Just like its predecessor, the whole thing is powered by a single CR2032 lithium battery with a rated life of 3 years. We haven’t had our unit for that long — we know, shocker — but despite us playing around with it quite a bit over the past few months, the battery indicator hasn’t dropped a single bit. This is promising!
Okay, there’s a bit more to the performance side of the story. While the STM32U5 series chip in the DM42n is capable of running at 160 MHz, it doesn’t always do so. In order to conserve battery power (and stay under the cell’s current limit), both the DM42 and the DM42n run their processors at 24 MHz in normal use. While the battery isn’t rechargeable, these calculators switch over to drawing USB power whenever they’re connected to a computer, in which case they bump their speeds up to 80 MHz and 160 MHz, respectively. While the DM42n only flexes its superior raw compute muscle when plugged in, the DM42 also has significantly less memory and RAM. It features 32 MB of flash storage and just 128 KB of SRAM — the latter of which can have some very real performance ramifications even at the base 24 MHz clock.
But how does the DM42n perform compared to some other calculators currently on the market? Well, let’s grab a few trusty models from our calculator drawer and quickly (and very unscientifically) compare. Given all that these run wildly different software on very different platforms (on very different hardware architectures), making any truly meaningful conclusions is rather difficult — but evaluating a reasonably similar expression and measuring how long it takes each calculator should give us a rough idea, even if only in terms of “well, it seems to us that x is a tad faster than y”.
We’ve chosen a short and sweet non-elementary integral: 
. This should be a bit of a challenge for the slower calculators! In addition to the DM42n, we’ve grabbed a selection of scientific and graphing models — an HP Prime, a Numworks N0110, and three Casio models: an fx-991EX, an fx-991CW, and an fx-CG50. Naturally, the graphing calculators were the fastest of the bunch, with the HP Prime leading the pack, closely followed by the Numworks N0110 and the Casio fx-CG50, in that order — all three delivering results almost immediately. The DM42n does take a second or two when running on battery power, but it fully catches up when plugged into USB power, crunching the integral pretty immediately — USB makes quite a difference! The fx-991EX and the fx-991CW, both immensely popular scientific calculators (with the CW model being an upgraded, yet somewhat controversial direct successor to the highly sought-after EX), were both significantly slower than the rest, taking more than 5 seconds to pop the result out, with the fx-991CW actually being slower than its predecessor, despite having a faster processor! (We’ll explain why in the next section where we dig a bit more into how calculators deal with numbers, so make sure not to skip it if you’re curious.)
Oh, and we also compared the DM42n with an original HP-32S from our collection, knowing full well that there wasn’t going to be any real competition. For fun! With its trusty Saturn core, it took the little champ from the 80s a little over a minute — 1:02 to be exact — to calculate the same integral. But it got it in the end! We’d have loved to have been able to run this test on an HP-42S, but sadly, we currently don’t own one. And sure, an HP-42S would’ve maybe been a tad faster due to its upgraded 1 MHz Saturn revision, but the difference simply couldn’t have been too great.
But there’s more than meets the eye to these results. See, numerical integration — what all these calculators are doing — always comes with a tradeoff between speed and accuracy, and there’s something interesting that all Casio models are doing, as well as the Numworks. If we take a look at the HP Prime and the DM42n’s result, we can see that both have printed out 3057488912.08. All other calculators simply round the result to 3057488912. Curious, huh?
All three Casio models have a hard limit of 10 significant digits displayed at a time — and while there’s more internal precision (15 digits in most Casio models, though 23 in some), there’s no way to view these guard digits and to stop the calculator from rounding the result to 10 (or less) significant digits. And this is why they keep spitting out the same result even with an integration accuracy parameter explicitly passed (we went with 
). And if you want to have some proper fun with one of these Casio units, try seeing what result 
gives you — and how then evaluating 
actually returns the proper value — it’s a wonderful demonstration of these guard digits doing their job.
The Numworks calculator does a tad better — though it displays 10 significant digits by default, it’s possible to reconfigure it to display up to 14, giving us some extra precision. Internally, it uses two extra guard digits, calculating things with a 16-digit mantissa. The HP Prime, interestingly, displays 12 digits by default, but also can’t show any more than that, with an internal precision of 15 digits. Surprisingly low for such a powerful system.
On the other hand, the DM42n has 34 digits of internal precision. Yeah — you’ve read that right. Though it normally displays up to 12 significant digits in the stack (effectively giving you 22 guard digits!), staying true to the original HP-42S implementation, the SHOW (accessible with ‘shift-[.]’) function enables you to peek at the entire 34-digit behemoth of a result in all its glory. There’s no extra internal precision beyond these 34 digits, so there will be some numeric noise in the final few, but this really shouldn’t bother any reasonable user. If anything, it’s to be expected. On top of that, the DM42n has an impressive exponent range — from -6143 to +6144. This is fantastic!
Since all calculations are done in respect of a machine’s internal precision, it’s safe to say that the DM42n has a lot more numerical crunching to get through, making its speedy benchmark results all the more impressive. Calculating our little integral torture-test down to 34 digits takes more than double the work it does calculating it to — say — 15 or 16 places.
A bit more on precision, numeric types and performance…
Okay — but why does all this happen and what’s with all the seemingly artificial limitations? Cue another one of our patented rambling tangents — feel free to scroll ahead to the software section if hearing about all the various ways calculators store numbers internally seems like a total bore (or just click here and we’ll get you there). You won’t miss anything too crucial about the DM42n itself.
Everyone who’s still here, let’s get started. All computer systems — which calculators most definitely are — have to store numbers using some sort of format that efficiently encodes the number’s mantissa, exponent, and sign within a singular, easy-to-handle value. Most people who have written a program or two should be familiar with common numeric types available in a number of programming languages. These are all your ints, floats, and doubles: binary formats well-suited for general computing. However, you likely won’t see a calculator using any of these to handle user input and calculation results. Why?
Well, integer formats aren’t terribly useful for pretty obvious reasons. This leaves us with floating-point formats. Standard float and double types, lovingly referred to as binary32 and binary64 (respectively) by the IEEE 754 standard that they often follow, are — unsurprisingly — binary formats. The reason these are standard is simple — computers work in binary, and designing software that uses these is comparatively simple and computationally efficient. But because people (of course it’s our fault) generally work in decimal numbers, want to tap such values into calculators, and expect similarly decimal results back, binary floating-point types would cause a lot of wonkiness. Cue the second ‘why?’ here: why?
Floating-point types are generally comprised of three bits of data: a single-bit sign, an exponent, and a mantissa, the length of the last two depending on the overall precision of the format, i.e., the space it takes up in memory — that’s where the numbers in the IEEE naming scheme come from. binary32, for example, has a biased 8-bit exponent and a 24-bit mantissa. (Though, due to some clever design, only 23 bits of it have to be explicitly stored, with the leading bit reconstructed according to exponent value. It’s usually assumed to be a 1, and really only needs to be a 0 for subnormal values, in which case the exponent is 00000000). Here, the mantissa does not represent an integer value, but instead a fractional binary number (hence some sources calling it fraction), with the implicitly stored leading bit to the left of the binary point, and the remaining 23 bits to the right. Combined with the fact that the exponent part also indicates powers of two — the decimal value represented is calculated as 
— it’s pretty easy to see why some base-10 numbers simply can’t be accurately represented in this system. As a striking example, even a simple value like 0.7 would have to be represented as 0.699999988079071044921875 in binary32, with the actual bits stored being 0 01111110 01100110011001100110011 (we’ve grouped them into sign, exponent, and mantissa for readability). This comes in a tad short, and even a standard 10-significant digit calculator would showcase this error, rounding and displaying the result as 0.6999999881. It’s pretty clear how it’d be very counter-intuitive to punch in 0.7 into a calculator, press enter, and then have it throw out a result like… that.
The next closest representable binary32 number, 0 01111110 01100110011001100110100, works out to 0.7000000476837158203125. This is even more inaccurate, meaning that 0.699999988079071044921875 is truly as close as we can get. Gah!
Thing is — this really isn’t a problem for computers and the thousands of calculations they do internally. Well, okay, it is, and mitigating floating-point errors incurred over tens of millions of calculations, or at least getting them to stick within an acceptable range, is an important part of system design. But all the intermediate results never have to be displayed in a decimal format to end-users — and, for crying out loud, these calculations are done in binary anyways and developers generally account for this fact. But calculators have to constantly interface every result, often an intermediate one, back and forth, and all the conversion issues simply add up.
And yes, all this can be somewhat mitigated by using progressively larger and larger floating-point types: binary64, binary128 and the like, but this isn’t truly solving anything, but rather pushing the error ‘off to the right’ a certain number of significant digits where it won’t be displayed. This is a very plausible strategy on essentially all modern computers, but on inexpensive, very low-power, often 16- or 32-bit systems with limited memory, such as many calculators, there are simply not enough computational or storage resources to pull this off.
Recall our example from the last section. Even though not caused by a binary-decimal conversion issue (but rather a rounding error while preparing the result to be displayed), it still wonderfully illustrates how ‘wrong’ intermediate results can introduce some unintentional human-centric issues. Imagine if someone were to manually copy over the displayed result and then use it in further calculations instead of accessing the internally stored answer value, accessible using the previous answer key. Sure, in this case it’s plenty obvious that something’s amiss, but a rounding error could be invisible to the operator in more complex calculations. This can lead to some very wrong results over time, especially in chain calculations, even though the calculator internally obtained and even — though in a somewhat convoluted way — made available to the user the right answer.
Let’s get back to our binary woes. There’s clearly a need for a different, more appropriate floating-point format. Enter decimal32, and its more grown-up versions: decimal64 and decimal128. Like their binary counterparts, decimal floating-point formats also store three fields. A single-bit sign is still present; but instead of fully separate exponent and mantissa fields, decimal floating-point numbers feature a combination and a significand continuation field (with the term significand often used here instead of mantissa).
We won’t go into too much detail about the inner workings of the encoding used here, as it’s a tad too complicated to be explained within the scope of a review tangent — but you can check out some materials here if you’re interested. The standard specifies two possible and quite different implementations, one encoding the mantissa as an unsigned binary integer, and the other using a method called densely packed decimal, which directly encodes 3 decimal digits using 10 bits.
Regardless of the encoding used, the combination field stores the entire exponent as well as some of the mantissa, while a whole lot of clever engineering also makes it possible to implicitly add three leading bits (specifically set as 100) to the mantissa, depending on the value of the first two bits in the combination field, thus effectively doubling the possible mantissa range. Certain values in parts of the combination field also allow for encoding signed infinities and zeroes, as well as NaN values. The significand continuation field is pretty self-explanatory: it contains the rest of the mantissa, after the implicit leading bit(s) and parts of it explicitly stored in the combination field.
Most importantly, the mantissa is an integer value, while the exponent denotes powers of ten — in the case of decimal32, the formula for computing an encoded number’s value is 
. It’s not hard to see why decimal floating-point formats make a lot more sense — and yes, 0.7 can be represented perfectly. No weird conversion errors.
There are some tradeoffs compared to binary floating-point numbers, however. There’s generally more processing overhead required to perform arithmetic operations on decimal floating-point numbers, and many quick-and-dirty sorting algorithms don’t quite work due to the encoding being more complex overall. Modern processors often come with dedicated FPUs designed for speeding up floating-point operations. These, however, are generally only compatible with binary floating-point numbers. Decimal floating-point numbers are also not normalized, meaning there’s no unique way to represent each value (like there is with binary floating-point numbers), but rather a cohort of possible representations for each value (e.g., 200 can be represented as 
, 
, 
, 
, 
, and so on), further complicating things.
But for a human-centric math device, these tradeoffs are well worth it. Many calculators, including the Numworks, use the IEEE 754 decimal64 format. It provides a wide exponent range (-383 to +384) as well as a 16-digit mantissa, enough for most calculator applications, while provisioning for several internal guard digits. decimal32 is thus rare, as it’s just a tad too restrictive for general calculations, though some lower-end four-function office models do utilize it.
Most of Casio’s offerings, including the fx-CG50, use a custom, modified decimal floating-point format that uses a single-bit sign, eight-bit exponent, and a BCD-encoded 15-digit mantissa (specifically upgraded to a 23-digit one in the case of the fx-991CW), but works in much the same way and offers the same benefits as the IEEE 754–standardized formats, if a bit less memory-efficient. Display results are then rounded and truncated to up to 10 digits.
The HP Prime also features a custom HP Real format that, again, works in quite a similar way. Data is stored, input, and output in a ‘packed’ 12-digit format: there are 4 bits for the sign (this is also how the Prime encodes signed infinities and various errors/NaN values), 12 bits for the exponents, and 48 bits for the mantissa, the last two using BCD encoding, like the Casios. Internal calculations are done in the ‘unpacked’ HP Real format, with 15-digit precision and a much greater exponent range, though this is never directly made accessible to the user, with results instead being packed back up (thus rounded to 12 digits) before they’re displayed or stored.
The DM42n sticks to the IEEE 754 standard but goes all in and uses the impressive quadruple-precision decimal128 format. With a 17-bit combination and a 110-bit significant continuation field, it’s an incredibly chunky format. The implementation on the DM42n sticks with encoding the mantissa as an unsigned binary integer. This is where the impressive 34-digit mantissa and huge exponent range comes from — it’s all part of the format’s specification. On top of having the best internal precision of any calculator we’re aware of, the DM42n is also the only calculator that we’re aware of that makes its full precision accessible to users.
We’ve already touched on the ramifications all this has on performance — precision comes at the cost of speed. But it’s not just about having to do more math — even just recalling and storing 128-bit values takes four instruction cycles for a 32-bit processor, like the one in the DM42n, and that’s not taking into account the computational overhead introduced by both the number encoding itself and, naturally, the extra work longer calculations require. And, with regard to all this, it should be clear why the Casio fx-991CW performs certain operations slower than the fx-991EX — it simply takes more work to compute and handle a 23-digit number than it does a 15-digit one.
Software and functionality: DMCP and Free42
Two critical bits of software make the DM42n tick: DMCP, SwissMicros’s in-house OS that handles all the low-level hardware interfacing (not only for the DM42n, but also other related models — the original DM42, the DM41X, and the DM32; keeping in mind that the most recent two, the DM42n and the DM32, use an enhanced revision called DMCP5), and Free42, Thomas Okken’s open-source HP-42S emulator. Free42 takes no original code from the HP-42S’s OS, instead being a complete, yet faithful rewrite designed to optimize for modern hardware past what the original ROM could deliver (that, and we’re also sure there were some legal incentives not to yank bits of proprietary code). It’s also Free42 that’s responsible for decimal128 support and the incredible precision offered by the DM42n — though there are also standalone binary64-based Free42 releases available for desktop computers. The latter do come with the drawbacks brought upon by binary floating-point formats that we’ve talked about in the last section — and might break compatibility with some legacy programs due to these, but are overall faster. (The DM42n, naturally, uses the decimal releases.)
Free42 is a relatively old project, releasing all the way back in 2004 with support for Windows, Linux, and PalmOS. Still actively maintained, Free42 now has official versions for Windows, macOS, Linux, iOS, and Android, all available for free download. It’s a great way to get started with the HP-42S in general, and is also one of the best stand-alone calculator apps out there, feeling especially satisfying to use on smartphones. The emulator is so faithful that the original HP-42S Owner’s Manual is still the best bit of reference literature. Sure, there’s some (optional) extra functionality that Free42 adds, but enabling it usually requires a short trip to the settings. Out-of-box, Free42 is set up to be as faithful to the original as possible.
But what does the original entail? At the end of the day — why use an almost 40-year-old calculator design? Well, to put it pretty simply, it was a brilliant calculator back then, and it’s still brilliant now. The HP-42S features an extensive programming toolkit, simple enough for absolute beginners to get a hold of, but full-featured enough to create graphical programs. The HP-42S’s customizable menu-driven interface still feels modern today, and the feature set is quite packed: there’s everything here, from support for complex and matrix calculations, to a more-than-capable solver and numeric integration program. The HP-42S also has statistics and probability functions, and is capable of base-n conversion and arithmetic. Naturally, there’s also the standard suite of scientific features: a complete set of trigonometry functions, logarithms, and the like.
Of course, there’s the whole RPN thing, which to some might be all they need to hear to immediately fall in love with the HP-42S. We’ve already discussed the merits of this input method, so we won’t repeat ourselves, but with a little practice, it really starts feeling incredibly natural and… intuitive, in a way — like you’ve got a lot more direct control of what the calculator is doing. With the HP-42S’s incredibly powerful implementation of registers and variables and a full set of stack manipulation tools, it’s even possible to indirectly address registers at the top of the stack. It’s RPN polished to perfection.
There are those who’d disagree with us here, claiming that HP’s finest entry system is Reverse Polish Lisp (RPL), thanks to its departure from keystroke programming and dynamic stack. And yes, within the HP calculator community, there’s a whole RPN-versus-RPL debate, but we won’t get into that — lest we get all the HP-28 and HP-48 series fans coming at us with pitchforks should we state our opinions. All you need to know is that RPN and RPL share a lot of similarities, including their reverse polish-ness, though they’re not that similar to use due to the differences that stem from basic design principles of the two systems, with the latter incorporating a rather object-driven approach to the stack, algebraic expression evaluation (…heresy…) and even some symbolic math capabilities. Curiously, RPL is actually the one that follows postfix notation to a fault — classic RPN models sometimes ‘break’ the rule for operations like storing and recalling variables.
If you’re used to modern calculators, perhaps the most striking (and at the same time, cool) feature of the HP-42S is the distinct lack of modes: everything happens within the stack, and the calculator is more than happy to accept almost any input. A matrix, a real and a complex number sitting right next to each other in the stack? Say less! Complex trigonometry and powers? The HP-42S can do it without a hiccup! In a calculator world so riddled with various math errors, apps, and modes for everything, and swathes of school-imposed limitations, it’s almost refreshing to be able to key in 
and get… well, not zero, as there’s no CAS here, but something like 
— rather impressive and effectively zero, not least because the expression even evaluates in the first place, no questions asked.
There’s also something special about the way programming interfaces with the rest of the calculator interface, with your custom programs assignable to menus, always accessible using a few simple presses. In some ways, dipping your toes into simple programming is required if you want to use the solver and integration functionality. And by gently easing users into the world of keystroke programming, it doesn’t take long for the HP-42S to become incredibly rewarding to customize, inviting you to fill it up with quick little programs that automate operations you perform often. It’s a world away from modern school-oriented calculators which often compartmentalize their programming functionality and stash it far away from the rest of your calculations. We’ll move on now, lest we turn this into an HP-42S review, but it’s worth noting that there’s nothing out there that feels quite like the HPs of old. And perhaps the best insight into why that is can be gained by flipping through a document we’ve already mentioned before — the HP-42S Owner’s Manual.
Free42 further refines the base HP-42S feature set, adding options for time calculations (nabbed from the HP-41 HP-82182A Time Module); some rather handy programming utilities, including the great FUNC command, used for preparing programs that behave like built-in functions (that is, don’t pollute the stack with their internal calculations), and an extensive list of additional conditional tests; as well as extra functions for handling strings and a brand-new RPL-inspired list data type. While the HP-42S already integrates many of the functions found on the HP-82180A Extended Functions & Memory Module for the HP-41 series, Free42 also adds the few that never made the cut. There’s also a set of miscellaneous commands that ease handling of matrices, complex numbers, and graphics.
The DM42n gets regular updates, which generally come with a new version of Free42 itself. Currently, the latest release is using Free42 3.2.6. The latest standalone Free42 release is 3.3.8 — with version 3.3 introducing some major additions to the HP-42S’s base-n toolkit. While it’s still not available on the DM42n, these features effectively bring most of the functionality from the HP-16C over. We’re pretty eager to see the team over at SwissMicros ship an update with this version out.
But perhaps the most standout feature of Free42 is its support for big stack mode — NSTACK — which turns the default four-level stack into an RPL-esque dynamic stack that’s only limited by the amount of available memory on your system. Sure, the calculator is still very much using the classic RPN system, but for those used to the way the HP Prime implements the stack, or simply find the traditional four registers a tad too limiting, this can be a very useful addition.
The DM42n itself packs some extra features that neither the original HP-42S nor Free42 have, including the ability to display all four (or more, if using the aforementioned big stack) levels of the stack at the same time. Also exclusive to the DM42n are special implementations of several of the HP-42S’s graphics commands, making them better suited for the native screen resolution. There’s a set of custom annunciators in the top-right corner, meant for providing a quick overview of the states of user-settable flags 0–10, as well as a set of internal virtual variables, holding several important hardware-related configuration parameters. These virtual variables are not a part of the DM42n’s variable table, and are only accessible using indirect addressing, thus normally being completely hidden unless you’re looking for them (this is a smart implementation, as virtual variables don’t even take up an unused flag, for maximum compatibility with third-party programs).
Finally, the keen-eyed among you might have noticed an extra row of function keys on the DM42n, which are dedicated to accessing on-screen menu items. On the original HP-42S, the top row of keys has to perform double duty whenever a menu is on screen, generally selecting menu items, but with a special little TOP.FCN button, accessible via ‘shift-[0]’, temporarily restoring the next top-row key press to its original function. This is clunky, especially for shifted top-row functions, as something like an 
requires four keystrokes to access: ‘shift-[0]-shift-[LN]’.
When there’s no on-screen menu active, the function keys can be used to access a menu unique to the DM42n. Here you’ll find a built-in reference guide, covering all the basics of using an HP-42S, as well as info on DM42n-specific functions and settings. This guide is stored as an .html file, complete with an interactive table of contents and hyperlinks for easy navigation. The menu also lets you set the buzzer volume, change the number font and display justification settings, as well as tweak the font size. If you spend a little bit of time mixing and matching options, you’re bound to find a display look you like. It might sound a bit silly, but seeing this kind of customization available on a calculator genuinely makes us happy.
With that being said, the font selection/sizing options are a bit rough around the edges with the big stack option enabled. Certain combinations work perfectly, cutting off exactly after a certain number of lines (generally between 5 and 8), but others have their topmost register only half visible, or worse yet, just barely peeking into the display area with a few rows of pixels. It’d be nice to see some sort of vertical line justification — or even simply hard coding the number of lines each combination of font and font size should display. This shouldn’t be terribly hard, especially given the fact that there’s really only one screen resolution this UI needs to support.
Talking about customization, the DM42n’s screensaver images (referred to as OFF images in the official docs) are fully customizable. There’s a bunch of endearing graphics that come preloaded on the device (we’re partial to the little microchip and “don’t panic” screensavers), but it’s also possible to curate your own collection and upload them to the calculator — as long as you make sure that you’re feeding it the required 400-by-240, 1-bit .bmp files.
As there’s no need for a TOP.FCN option on the keyboard, the DM42n replaces it with a setup key. The setup menu is quite packed. The first set of options is used for file transfers, letting you load and save programs, as well as transfer files between the calculator and a PC. DM42n also fully implements Free42’s handy calculator state system, allowing you to store and recall virtual “workspaces”, pre-configured with the programs, settings, and variables required, all separated into their own self-contained units. And you don’t have to worry about things going awry, as it’s always possible to recall the last-saved version of each state.
And yes, unlike many school-sanctioned calculators, the DM42n does store all its data after power off, much like the HP-42S. A programmable model without continuous memory would be quite a horrible beast to use — but having continuous memory, especially in tandem with communication features (while absolutely lovely for personal and professional use) can be a hurdle when it comes to getting a model exam certified. SwissMicros’ support for third-party software running on the thing doesn’t make things much better — remember the lockdown controversy Numworks had to face in order to make their product more appropriate for the education market? Now, of course, the DM42n is aimed at aficionados, so its exam-worthiness isn’t a contested topic, but we still felt it important to take second and lay out the facts.
The setup menu also has options for tweaking printing behavior, as well as a pretty extensive list of general calculator options. The DM42n keeps track of date and time and has a customizable status bar which can display multiple bits of info, including the currently loaded calculator state and battery voltage. There are also options to tweak the number (and type) of registers shown — the DM42n’s default XYZT display can be replaced with the more traditional two-line XY layout, or expanded to include Last-X or Alpha registers. There are even some hybrid options, like XYA or XYL (though it’s pretty intriguing if this is what you choose to use given all the screen real-estate). Each register can also have a user-definable font size offset, which is pretty handy if you’re using a five-line layout and want, for example, bold and easily readable X and Y registers, with smaller Z, T, and L ones.
Finally, a couple of miscellaneous checkbox options are peppered in: you can disable Free42’s dynamic stack functionality, mute the DM42n’s buzzer, or tweak key auto-repeat speed.
The DM42n also features the system menu, which contains some lower-level functions. For most users, there’s usually no need to venture this deep — and the interface even throws a warning to save your calculator state before venturing into the system menu, as there’s a potential for data loss. If you do decide to peek inside, you’ll see a number of options for updating the firmware, accessing the bootloader, formatting the entire calculator, or performing a number of hardware self-tests. All fun stuff — but one of the options, Reset to DMCP menu, caught our attention. Woah, there’s even more?
When you turn on the DM42n, DMCP loads up a selected program — by default, a customized version of Free42 packages with all the extras into a file named DM42PGM — but it’s not the only program it can load. SwissMicros has the DMCP SDK available on their GitHub, so it’s possible to write your own programs for the platform. The developer documentation is pretty sparse, but despite that, there are already a number of fan-made third-party projects, like DB48X, WP43, and C47 (there’s even a little hush-hush story that SwissMicros is working on releasing a hardware calculator running C47, but shhh). Why is all this relevant? Well, it’s the DMCP menu that lets you load and run custom programs, as well as poke at some low-level bits of software that you definitely shouldn’t unless you know what you’re doing.
Overall, the DM42n’s software feels no less polished than the famously stable OS of the original HP-42S. There are all-around enhancements brought by both Free42 itself, as well as SwissMicros’s own work adapting it for the DM42n. Support for third-party firmware is delightful — as is the customizability. In short — this calc’s software is in no way lagging behind its gorgeous hardware. Modernization at its finest.
Verdict and alternatives: who’s the DM42n for?
Well, let’s get the obvious answer out first: if you’re an HP calculator fan, a long-time user of the HP-42S, a Free42 user who wishes your calculator was a bit more… physical, or simply a calculator aficionado — or perhaps all of these — with deep enough pockets to afford the DM42n, get it. It’ll bring you oodles of joy for years to come.
Now, the deep pockets part is not a joke — a new DM42n unit will set you back a cool 259 CHF, which is about $320. This isn’t terribly high, but it’s a significant chunk of change for a calculator, especially since a lot of popular scientific models go for sub-$30 prices nowadays. Calculator collectors might be a lot more accustomed to prices like these. A good-condition HP-42S will cost you a pretty penny, and finding one — while not terribly difficult — is certainly harder than finding a DM42n.
But it’s hard to complain about the price. SwissMicros is a team of four people hand-making these niche products in Stäfa, Switzerland. Given the work required to make just one of these, not accounting the R&D costs and the quality of the materials and components chosen, makes every DM42n feel so special. And these aren’t exactly mass-produced, either, with our review unit bearing 00317 as its serial number — gosh! It’d take a pretty stone-hearted person not to appreciate and want to support what the SwissMicros team does. They’re keeping a legacy alive.
You’ve heard us gush about the hardware and the software, so we won’t do that again here. But perhaps the price is a tad too steep for you, or you just aren’t into the idea of calculators enough to spend so much on one. Well — alternatives exist, though none truly compare.
Most obviously, there’s the option of trying to track down an original HP-42S, but let’s be honest here — if you’re someone who’s considering an undertaking like this, you’ll likely still want a DM42n after getting an HP-42S, and vice versa. Just… just trust us on this one, okay?
Another obvious choice is sticking to Free42. And this is a pretty faithful, at least feature-wise, and rather resourceful way to substitute the DM42n. In fact, if you’re in the market for one of these calculators, but don’t have a lot of experience with the HP-42S itself, spending some time with Free42 before pulling the trigger can be a very useful way to gauge whether the whole shtick works for you or not.
Now, of course, using Free42 is nowhere near as — for the lack of a better word — sexy as using the DM42n. The physicality of the entire experience: reaching for it and taking it out of its pouch, interacting with the tactile keyboard, getting the results right there on its gorgeous panel — it’s not replicable by anything else. In a world where everything keeps getting more and more integrated and where AI-created slop is being force-fed to us all, taking a step back and just… beholding a little device proudly made for a certain purpose is a (sadly) unexpected treat.
HP’s modern (or, for the sake of completeness, any other calculator manufacturer’s) offerings, are cutting it either. The last classic calculator they’ve pushed out is the HP-35s, which got discontinued in 2021, with used units now fetching prices north of $300, despite the original retail price being $60. Recently, there’s been a limited edition re-release of the HP-15C, which might scratch an itch for some, but it’s no 42S (though a legendary model in its own right). It’s also not exactly cheap, going for ~$120.
Finally, SwissMicros does still offer the older DM42 model, which comes with a slower processor and aging Micro-USB instead of USB-C. The ~$12 price difference is hardly worth penny-pinching for. Other SwissMicros models, like the DM41X and the DM32 are priced similarly, due to all these models sharing similar hardware. It’s worth checking them out if you’re interested in the models themselves, but not as a cost-saving measure.
And that’s kind of it, as far as authentic RPN experiences are concerned nowadays. Were it not for SwissMicros, we’d be stuck between discontinued models and collector’s editions, buying historic units from the 80s — and while there’s charm in everything, there’s a special kind of love that emanates from the DM42n and its earnest mission to bring a long-missing icon back.
