Clockwork Pi DevTerm review

If you were to squint just right, Clockwork Pi’s DevTerm, with its retro-inspired ultra-wide display and characteristic two-tone body could pass for a TRS-80 Model 100. Fully inspired by the first generation of truly “pocketable” computers, the DevTerm feels like a love letter to these systems of days long gone.

That’s not to say the DevTerm has no visual identity of its own. It does. There’s plenty of modern yet playful touches that help it avoid feeling outdated. A whimsical contemporary take on expansion ports of the old? Check. Adorable chunky thumbscrews holding the whole thing together? Check!

Nowadays, it seems like most consumer-oriented devices are carbon copies of each other, at least when it comes to their looks (although a similar point could be made about the actual features, too). Endless arrays of boxes big and small trying to be sleek-as-can-be inevitably results in pretty converging appearances. This lack of general design whimsy didn’t go unnoticed, and quite a few niches in tech and media are experiencing a retro renaissance of sorts (looking at you, indie games). And if mentioning games here feels a bit out of place – it’s not. The DevTerm was made for playing and creating indies. Dubbed a “portable terminal” by its manufacturer, it was designed to run software like PICO-8, TIC-80, open-source engines like Godot and emulation platforms like RetroArch. How nifty is that?

Even better – you get to assemble it yourself. Designed as a DIY kit, the DevTerm packs all of its components in a series of ready-made modules. Putting the device together feels like building a LEGO model, which makes for a surprisingly polished experience that’s quite streamlined but still rewarding.

Inside the box, all of the components are placed in two blister packs | photo: magazin Mehatronika

This isn’t the first such kit that Clockwork Pi, the company behind the DevTerm, has put out. Their debut product, a retro portable console called GameShell followed the same design philosophy, and we’ve seen further refinement of the concept in the uConsole, a dedicated fantasy console (and a spiritual successor to the Pocket C.H.I.P. of sorts).

But aside from being a real blast from the past – what’s the DevTerm made for?

All of the DevTerm’s key hardware is modularized | photo: magazin Mehatronika

Hardware overview

At the heart of the DevTerm lies one of several cores – custom SODIMM-format SoMs designed by Clockwork Pi for use in their devices. These pack an SoC together with RAM as well as some additional circuitry. Essentially, all of the processing power resides here. Depending on which core you go for, you can kit out your DevTerm with an ARM or a RISC-V processor, as well as pick from a selection of RAM sizes (and types – dependent on your SoC of choice).

The DevTerm can also take a standard Raspberry Pi Compute Module 3+ or Compute Module 4, though the latter needs an adapter board, which Clockwork offers for $19. Both of these are officially supported (and in fact, as we’ll elaborate later, probably have the best overall software support). You can get the DevTerm pre-equipped with either through the manufacturer’s store.

Thanks to the system’s modular nature, you’re not stuck with the specs you initially choose, as swapping a core out for a different one is, quite literally, a five-minute job. This is because all DevTerm models share identical hardware, with “models” really boiling down to which core you want to have thrown into the box. In fact, you can even buy a DevTerm kit without a module included if you’d rather make that choice later.

Price-wise, the “full” DevTerm – module included – starts at $239 and tops out at $339 for the highest-end option. This precisely correlates with pricing of separate modules, with the most affordable core starting at $29 with prices going up to $129 for the beefiest one.
The DevTerm comes in very nifty silver packaging. Flipping the lid open reveals several trays of components and PCBs, as well as a whole lot of plastic parts on part trees. It was a bit nostalgic, admittedly, as it felt a lot like one of those old-school scale model kits. While we thought removing all the parts would be quite tedious, the plastic turned out to be rather forgiving. We initially started going at it with flush cutters (guided by our resin printing and model-making instincts), but quickly realized that even twisting parts off (barbaric, we know) doesn’t leave any scuffs on the surface finish.

The provided instruction manual is great, with clear graphics every step of the way. Ironically, the first step is probably the most difficult one: installing the screen. Be careful, as it seems it’s a relatively fragile component. Some people have been reporting breaking theirs during installation despite being careful, and even having screens dead on arrival. Not a lot’s known about whether this is due to user error or some sort of QC issue – but the community seems to be working actively with Clockwork’s design team to resolve it.

In order to streamline the assembly process, Clockwork decided to group the DevTerm’s internals into several modular blocks. The “main” board features an SODIMM slot for the core module, as well as some of the ports. The “extension” board features a cooling fan alongside several more ports and internal connectors. Thermal printer and battery holder? Both are their own discrete modules. Building this first layer of the DevTerm is essentially as simple as snapping these four side-by-side(-by-side-by-side?) onto the midframe and connecting a few ribbon cables.

The keyboard, trackball and game controls are all integrated into a single module which sits atop the others. It’s connected via a set of gold-plated pogo-pins which make contact as soon as the keyboard gets snapped into place. After this module sandwich gets assembled, all that’s left is the outer shell. It snaps around the bottom of the device and locks using two custom thumb screws.

Clockwork went as far as to design custom thumb-screws for the unit | photo: magazin Mehatronika

One unique thing about the DevTerm’s design is the fact that it’s held together with no screws whatsoever. Everything is friction-fit. This did initially make us a little nervous about the final build quality, but we were quite pleasantly surprised. The finished unit does have some case flex, but it’s not significant or distracting in any way. The keyboard deck itself is very solid – surprisingly so for an all-plastic build.

This sort of design does have one key advantage – it’s extremely easy (almost inviting) to open up the whole thing up and tinker around. Some modules, like the keyboard, even offer hidden internal USB ports which let you update their firmware. If you want to tweak the way you keyboard works, or develop a custom module for the DevTerm, the options are there.

All that aside, we were a bit surprised with how compact the finished device is. Measuring just 20 cm across and 16 cm tall, it’s quite a bit smaller than we thought it’d be. Perhaps foolishly, we’ve expected the keys to be close-to-regular-sized, which would make the unit more or less as big as the TRS-80 it draws inspiration from.

Nope! The DevTerm has some of the smallest physical keys we’ve ever seen on a QWERTY keyboard. These feel more like calculator keys. In fact, they’re a little smaller than the number keys on the Casio fx-CG50 and are about as large as the number keys on the Numworks (we know, niche references – but buttons like these are calculator territory). Sadly, this does mean that you likely won’t write your next New York Times bestseller here, and likely won’t be programming for long stretches of time, either. It’s far from an ergonomic board and we’ve found that “hunting-and-pecking” (or even thumb typing, if you’ve got large enough hands) works better than touch typing simply because it’s too cramped – all the while hitting keys off-center keeps causing them to bind and trigger multiple times. This makes us wonder why Clockwork chose to fit a miniaturized 65% keyboard instead of a 40% one with more “grown up” keys, as we feel it’d have helped. Maybe we’re just missing a special dialing wand…

One final gripe with the keyboard – and this might make us sound quite nitpicky – has to do with the keycap printing method used. The labels are pad printed. This isn’t great for durability, as pad printed labels tend to rub away with time. We would have much preferred dye sublimation keycaps – even if that meant having to switch to much more boring black-on-white keys. The true solution here would have been proper double-shot keys – but that would require a significant amount of ridiculously expensive custom tooling since no keycap manufacturer offers caps of this size.

The keyboard module includes a trackball and some gaming controls. According to the manufacturer, the trackball uses hall effect sensors, which should make it pretty reliable in the long run. We don’t have any complaints here – except maybe the fact that pointer acceleration could be a bit more robust. This should be pretty easy to fix via an update, and we’ve already seen community-made keyboard firmware mods for tweaking tracking response.

The gaming controls are a mixed bag. The Nintendo-style face buttons get a pass – even if a little mushy and rattly. They’re also oddly tall and have sharp edges, which prevents smooth gliding between the keys. The height is probably the reason they rattle in the first place. If they were significantly shorter, we could see them feeling a lot like Nintendo Switch Lite buttons.

The face buttons are located right by the keyboard, and are part of the same module | photo: magazin Mehatronika

The D-pad, however, is a jiggle fest. The even sharper triangular edges also don’t help your thumb glide smoothly (these were modeled after retro microcomputer D-pads, but there’s a reason we’ve moved away from the design), and there’s no well-defined feedback to know whether you’ve actually pressed a button. For relaxed, casual games, this is fine, but we don’t think more involved titles will feel too great on here.

Since the keyboard is modular, we feel there’s more than enough room for Clockwork to release an updated – if a bit more expensive – version with better face buttons and perhaps slightly larger keys. It’s also a bit of a missed opportunity that clockwork doesn’t offer alternate keyboard modules – letting people choose between a 40% and a 65% keyboard layout, for example, or offering several switch designs.

Right above the keyboard is the screen, and it’s gorgeous. It’s a 6.8” IPS display, which gives it vibrant colors and some great viewing angles. The curious 16:6 aspect ratio and 1280×480 resolution (this is essentially two VGA monitors side-by-side: a standard VGA panel is 640×480) make it immediately stand out. While definitely a design-driven decision, an exotic display like this ends up being quite practical for tapping away long commands in a terminal window or running two apps side-by-side.

Even at an angle, and under intense light, the IPS panel remains legible | photo: magazin Mehatronika

Games look great, interface elements look sharp – and if we had to complain about one thing, it’d probably be the lack of vertical space. Certain windows and pop-ups simply require more than 480 pixels, which does, at times, lead to some critical UI elements getting rendered off-screen, making it tricky or impossible to access them. There are several software workarounds, but here’s the one we use:

xrandr –output DSI-1 –panning 1280×1440

for getting additional vertical real estate you can pan through and

xrandr –output DSI-1 –panning 0x0

for returning your screen back to normal.

You can alias both of these commands to something that’s easier to type – we used ‘p’ and ‘up’ (short for “pan” and “unpan”) as it (apparently) made sense to our review team.

Ports-wise, the DevTerm is pretty decently equipped. There are three USB 2.0 Type A ports, a USB-C port for charging only, a micro-HDMI port for video out and a 3.5mm analog audio jack. USB 2.0 is pretty slow by today’s standards, offering up to 480 Mbps (which works out to around 60 MB/s).

The left IO plate houses a single USB 2.0 port, a USB-C port for charging, a Micro-HDMI port and a headphone jack | photo: magazin Mehatronika

At least a single USB 3.2 Gen 1 port would have been nice for accessing faster storage media (especially since many of the cores natively support it – but we guess the team had to settle for the lowest common denominator between all SoCs on offer). But for programming the odd Arduino board, moving small documents to and from a flash drive, and powering small peripherals, the available ports should do the trick.

The systems also features both 2.4GHz and 5 GHz Wi-Fi as well as Bluetooth 5.0, which is super handy. This is something 80s computers definitely didn’t have.

The other IO plate is simpler, housing the final two USB 2.0 ports | photo: magazin Mehatronika

The battery life on the DevTerm is okay, but will depend on your core module of choice – and obviously, batteries of choice, as those aren’t included in the package. The system takes two 18650 Li-ion cells, but can also run using just one. We usually get between 3-5 hours on a single charge using two Panasonic NCR18650B cells, and it takes us around two hours to fully charge the device. Connecting a lot of peripherals, using the thermal printer, or simply running demanding software does drain the battery significantly faster, so keep an eye out on percentages as we’ve managed to unexpectedly run out of juice several times during testing.
Finally, there’s the just-mentioned thermal printer. By far the most whimsical of the DevTerm’s features, this printer actually has pretty decent specs. It prints at 200 DPI on standard 58 mm thermal paper rolls, so the output result is pretty consistent with what you’d get out of a cash register.

That orange is mesmerizing… | photo: magazin Mehatronika

The printer itself lives inside the main chassis of the DevTerm, with the cartridge-inspired “Expansion Port” used for inserting a detachable paper roll cassette.
The paper cassette itself is worth mentioning, as it’s a brilliant little bit of design. It fully encloses and protects the thermal paper roll, and even comes with a little cap to prevent the paper from fraying or unfurling in transport. Sure, there’s nothing groundbreaking about its function – but we find the overall implementation quite nifty.

Now that we’ve covered all of the hardware that’s identical across all of the models, let’s dig a bit into the stuff that’s different – the core modules – and check out which one would be perfect for you.

Selecting the right core module

The Raspberry Pi Compute Module 3+ and Compute Module 4 are both quite self-explanatory. You can either supply your own module or get one included with your DevTerm. Clockwork only ships Lite versions of both of these, as having on-board storage completely disables the built-in SD card slot, normally used as the main system disk. If you’re absolutely set on using eMMC instead of an SD card, you’ll have to bring your own module. Make sure to opt for one with enough storage space, as you won’t really be able to expand it without swapping the CM itself.

The official Clockwork store also doesn’t seem to stock any 8GB RAM CM4 units – or at least didn’t at the time of writing – so if this is something you’re interested in, you’ll too have to bring your own module along for the ride.

Both the Compute Module 3+ and Compute Module 4 offer enough performance for desktop use, but we’d still nudge everyone towards the CM4 with its four Cortex-A72 cores. The aging CM3+ is really starting to show its age, so we’d steer clear of it for this reason – unless you’ve got a spare one just lying around. The newer module is just that much faster and more capable, which makes pretty much everything you’d want to do on the DevTerm a breeze. We’d know – Clockwork sent us a CM4-based review unit. We’ll dig a bit deeper into the exact performance numbers of our unit in the benchmarking section of this review – but you should expect virtually identical performance to a stock Raspberry Pi 4.

Perhaps the best thing about both Raspberry Pi Compute Modules is their amazing software support. Everything just works – and if it runs on a stock Raspberry Pi, it’ll run on a CM-powered DevTerm too. No other core offers this level of software support.

Clockwork’s own modules come in three variants. There’s the RISC-V-based R-01 core, and two ARM-based ones: the A-04 and the A-06.

The R-01 is definitely the most curious choice, sporting Allwinner’s D1 SoC. It’s a RISC-V SoC, which makes it quite special – its ISA is fully open-source! It’s not the most performant though, featuring only a single RV64GCV core running at 1 GHz (official Allwinner documentation points to this being a T-Head C906 core). With just 1 GB of DDR3 memory and no on-board GPU of any sort, you’re probably going to want to stick to a CLI if you opt for this core.

Limited performance is, surprisingly, not as much of a roadblock as is limited software support. RISC-V is a very young platform in the grand scheme of things and there’s still a lot of kinks to be ironed out. Don’t get us wrong, it’s impressive how much has been done already – the first Linux capable RISC-V SoC only came out in 2018 – and we have had quite pleasant experiences with RISC-V boards in the past, but they did require a significant amount of know-how and willingness to tinker with things that definitely should but definitely aren’t working.

In short: if you’re looking for something unique and experimental, and aren’t afraid of getting your hands a bit dirty – scratch that – are interested in getting them dirty, picking the R-01 up might be ideal. For almost everyone else? We feel another core would be better.
The A-04 and A-06 are both ARM-based cores. The former features an Allwinner H6, a quad-core Cortex-A53 chip running at 1.8 GHz. Featuring 2 GBs of DDR3 RAM and a Mali-T720 GPU, it’s roughly on par, if a little faster, than the Raspberry Pi Compute Module 3+ in terms of performance.

The A-06 uses a higher-end Rockchip RK3399 SoC paired with up to 4 GB of LPDDR4 RAM. The six-core heterogeneous Cortex-A72 and Cortex-A53 mix makes this the fastest chip on offer here. It’s even a bit faster than even the Compute Module 4, but chews quicker through batteries, too.

Both the A-04 and A-06 have decent software support. It’s certainly a lot better than on the R-01, but it’s also not quite as smooth of an experience as the Raspberry Pi modules offer. Issues are especially evident with GPU driver support – even though both the A-04 and A-06 pack much more powerful graphics processors, they often get outperformed by weaker hardware simply due to better software optimization. This is in no way Clockwork Pi’s fault.

We’ve seen this same issue time and time again on so many SBCs using Amlogic, Allwinner or Rockchip SoCs. The reason is simple – these manufacturers often don’t share the required documentation and software, leaving board manufacturers in the dark. Even though popular, a lot of boards like these have to rely on community support to get things up and running. As an example: in the absence of official drivers, almost all Rockchip boards have been relying on a community-made “Panfork” driver to get any sort of hardware graphics acceleration for years.

Besides, while we’re still waiting on Raspberry Pi to come out with a Compute Module 5 (come on already), we wish that Clockwork Pi offered a core based on an even more powerful SoC. Something like the Rockchip RK3588 (it’s literally twice as powerful as the RK3399, and it’s the new superstar in the mid-range SBC world, capable of emulating PS2 titles or crunching through compilation tasks) or even the Amlogic A311D would have made a lot of sense. Throw in 8 GB of RAM into the mix, something none of Clockwork’s own modules currently offer, and we’d have a clear heavy-lifting champ.

The way it is, however, we’re inclined to recommend the Raspberry Pi Compute Module 4 as the top choice for most users, followed by the A-06 for those looking to get the best possible performance and are happy to sacrifice some battery life and software support.

The A-04 and CM3+ are somewhat similar, with the former being ever-so-slightly faster – especially when it comes to graphics performance. These are among the less expensive cores, and might make a lot of sense if you’re trying to save a few bucks. They aren’t the fastest, but stuff can definitely run decently.

Finally, the R-01 is hard to recommend to anyone who doesn’t know exactly what they’re getting into (…it’s as if it were made by Sirius Cybernetics Corp…). If you see the appeal of having a portable experimental RISC-V device, this one might be ideal for you. If you don’t – skip it. You’ll mainly be missing out on a lot of bugs and headaches.

Benchmarks

It should be pretty clear by now that your benchmark results will heavily rely on the core you pick. Since we only have one core – the Compute Module 4 – we can’t cross-compare the cores but we can make a good approximation using results from systems with the same (or very similar) specs.

Because of this, we’ll skip out on tests related to memory or storage performance and focus on SoC-oriented numbers, as the former depend on the board as much as they depend on the main processor.

We always keep going on about how synthetic tests are in no way a comprehensive (or fully accurate) resource, and that’s especially true here due to the modified testing methodology. We’ll be updating this article with more accurate results if we get a hold of some of Clockwork Pi’s own cores.

We’ll be using our CM4-based DevTerm and comparing it to a Raspberry Pi 3B+ (which should be identical in performance to the CM3+), as well as a RockPro64 (a RK3399-based board). We’ll be throwing in Raspberry Pi 5 results in too, just as a reference.

Starting off with Geekbench 5, we see just about what we’d expect – the DevTerm’s CM4 gets a decent 204/592 score, while the RK3399-based RockPro64 pulls ahead with ~40% better scores. The new Raspberry Pi 5 leaves both of these in the dust – but to tap into that sort of performance, we’ll have to wait for the CM5 to (hopefully soon) arrive.

Due to only having 1 GB of RAM, the Raspberry Pi 3B+ couldn’t run this test.

Unlike Geekbench, which specifically taps into heterogeneous systems’ power, the Sysbench CPU benchmark relies a lot more on core count and clock speed due to being based on much simpler operations. The scores here are naturally closer, with the RockPro64 only having a slim lead. The Raspberry Pi 5 still pulls ahead greatly thanks to its blazing fast Cortex-A76 cores, while the Raspberry Pi 3B+ seriously lags behind.

The OpenSSL test shows an interesting quirk in the design of the BCM2711 and BCM2937: both of these chips lack hardware encryption acceleration. It’s a bit of a long story why, but the Raspberry Pi 5 is the first in the series to feature hardware encryption. Rockchip SoCs, on the other hand, all have this functionality enabled – the RK3399 included – which should explain the huge lead both the RockPro64 and the RPi 5 have in these tests.

Finally, UnixBench. A generally simple benchmark suite (similar to the Sysbench CPU one), UnixBench also has tests which depend on OS stability and optimization. Overall, the single-core results below are pretty much what you’d expect – with the Raspberry Pi 5 leading the pack and the Raspberry Pi 3B+ trailing it.

There’s no surprise in multi-core results, either. The CM4-based DevTerm sits comfortably in the middle, quite close to the RK3399-based RockPro64. This is the test where the BCM2937’s age shows the most – and probably best explains why we advise against picking up the CM3+ DevTerm model.

That’s a wrap for this little benchmark section! While we’ve already hinted at relative performance levels in the previous section, we feel these help further illustrate what sort of power some of these core modules pack.

Software support

We’ll be short here, as there’s not too much to talk about. The DevTerm officially supports Clockwork’s own custom Armbian image, known within the community as clockworkOS. Manjaro ARM nightly builds also generally work, and if you get a Raspberry Pi-based DevTerm, you’ll get access to Raspberry Pi OS, too (as well as most other Raspberry Pi-compatible operating systems).

This is why we mentioned earlier that our top core pick would have to be the CM4. The utility of access to the full Raspberry Pi ecosystem cannot be overstated – it’s the largest tinkering platform out there, with the most active community. Getting an RPi-based DevTerm essentially makes a lot of things you know and love about the Pi carry over, and it’s great. In the end: if something goes wrong, you’ve got two communities to whine to.

The A-04 and A-06 are fun in their own way (especially the A-06 with its awesome performance gains), but software support is more limited – there’s only clockworkOS and Manjaro.

On the other end of the spectrum lies the R-01. It’s super fun to mess around with, but for most people the effort required to get things working the way they should won’t be worth it. Only clockworkOS officially works here – but we can’t ourselves vouch for its exact stability.
On our CM4-based DevTerm all of the software worked perfectly, too. We tried running PICO-8, TIC-80, LibreOffice and GIMP; we tried surfing the web using several explorers and even printing some PDF documents using the thermal printer (felt silly) – and ran into precisely 0 issues.

Look – that’s our logo! | photo: magazin Mehatronika

Whether this level of compatibility is there on DevTerms sporting non-Raspberry cores, we can’t tell. Our experience from other SBCs and similar boards makes us doubt it, but perhaps Clockwork’s got some magic under the hood that makes for a much smoother overall experience. Most things will probably still work, but definitely expect a few hiccups (that you’ll have to rely on the community for) along the way.

Conclusion

Whew! This was a bit of a longer one – somewhat unexpectedly. If it wasn’t clear already, we really like the DevTerm. We love its concept and the execution is mostly great with a few flaws mostly concentrated in the keyboard region.

There’s just something undeniably cool about this device. From the moment we took its pieces out of the packaging it drew us in, and even though we still aren’t quite so sure what exactly is so appealing about it, that childlike sense of wonder is there whenever we interact with it.

Scratch that – we wanted one the second we saw it on Clockwork’s website.

The DevTerm, despite being retro, looks quite good in a modern desktop environment | photo: magazin Mehatronika

But one question does remain, hailing all the way from the beginning of this review – what’s the DevTerm made for? Better yet – who’s the DevTerm made for?

Well. Being a little too large to replace a tablet and a bit too small to replace a laptop, it lives in a limbo between easy-to-carry and “you’d-want-this-on-a-desk”. A coffee table somehow feels perfect for it – sitting there on display, ready to be picked up when the need arises.

What would this need be? We’ve found tinkering around with fantasy consoles immensely enjoyable on the DevTerm. Everything about it feels tailor-made for this use, and if the keyboard were just a bit better, it’d probably be our favorite way to consume and create PICO-8 games.

On the other hand, we realized during testing just how nifty the DevTerm is for quickly SSH-ing into other devices (especially thanks to that wide display), or for programming Arduino boards and other development kits on-the-go. You can shove a full version of the Arduino IDE on here and work with a huge selection of MCUs – all while running on battery power.

That thermal printer is undeniably cool. It’s a bit of a shame that China seems to be a lot more into consumer-grade thermal printing than the West, so there’s a lot more cool thermal paper options that are easy to get over there – including ones with multi-colored thermosensitive ink or fun designs printed. Fancy!

Printing on the DevTerm really doesn’t get old | photo: magazin Mehatronika

The more we used the DevTerm, the more we realized it’s got some genuinely awesome uses, and we’re pretty sure we’ll discover quite a few more down the line – and that anyone who gets one will also find some unique ones too. Does this mean everyone should run out and grab a DevTerm kit right away? No. But does just looking at one make us want it?

Absolutely yes.

• About
• Latest Posts

Dušan Dakić

Writer/Comms manager at magazin Mehatronika

Dušan has been with magazin Mehatronika since 2019, focusing on tech reviews and how-to articles, as well as handling communications with our partners worldwide.

He’s also the key person behind Mehatronika's English translations, especially of education- and maker-oriented texts.

Latest posts by Dušan Dakić (see all)

• Raspberry Pi AI Camera review: Even more approachable AI - 10/22/2024
• Arturia AstroLab review - 09/29/2024
• Raspberry Pi AI Kit review - 08/16/2024