The Resurrection of the Computer Fridge

img_20190731_1837407130935668874283186.jpgThe computer fridge hypothesis is a seemingly brilliant idea: store and operate your computer in a fridge, and wave good bye to all heating issues.

However — in 2015, a disappointing video appeared on YouTube: Linus Tech Tips once and for all rejected the computer fridge hypothesis by an experiment showing that refrigerators always loose in thermodynamic battles against modern computers.

The heat dissipated by the personal computer will exceed the heat absorption capacity of the fridge evaporator — causing the ambient temperature in the fridge to rise rather than fall. If we consider the system as a whole, we have a serious self-heating problem, and there is nothing we can do about it.

Or is it?

Cracking The Self-Heating Problem

Pleasant ideas deserve to be treated with respect, right? They should be tried from every angle before being trashed. From first principles, I decided to challenge the rejection of the computer fridge hypothesis by proposing: the ventilated computer fridge hypothesis!

The Ventilated Computer Fridge Hypothesis

A Ventilated Computer Fridge

The ventilated computer fridge hypothesis is based on the following reasoning: If the fridge is equipped with a balanced ventilation system, most of the heat dissipated by the computer will be transferred out of the fridge, so there will be no self-heating. When the fridge is turned off, the system will simply function as a normal computer cabinet. Now, if we in addition route the in-air stream via the evaporator, the air will be cold when it hits the computer, thus absorbing heat from the computer on the way out of the fridge. See the sketch on the right.

I decided to test the new hypothesis, so I had to build my own computer fridge.

Building a Computer Fridge

I bought a second hand mini-fridge with a glass door from TempTech on eBay as a starting point.

Installing Balanced Ventilation

bb138b1h3790128944658168010.jpgI decided to install a simple balanced ventilation system represented by four Corsair ML140 Pro cabinet fans.

While the task of installing four fans in a mini-fridge is not the most pleasant thing a human being can do in the world — it can be done by some laborious drilling on the outside, and heavy angle grinding on the inside.

My friend Øyvind Colliander created a nice template for the drilling part. See the fan hole template below. The trick is to tape a printed template to the fridge wall, and use a punch and a hammer to mark the center of the holes before drilling. For the angle grinding, put on a face mask and cut out four squares on the inside aligned with the holes on the outside.

Result: two fans on the upper back (in-air), and one fan on each side (out-air).

Fan holes on the sides
Fan holes on the back
Fan hole template for Corsair ML140 Pro (A4 print-friendly PDF)

Bypassing the Thermostat & More

In order to get full control of the fridge’s cooling system, I bypassed the internal thermostat and instead installed an Arduino micro controller and an external relay board beneath the back plate on the inside of the fridge. I also permanently installed the Arduino DHT-11 sensor to get ambient temperature and humidity readings. The sensor is placed in the bottom right corner of the fridge. I drilled holes on the backside for 230 VAC power and Ethernet, and installed a power socket, as well as two AC/DC converters (36 VDC & 12 VDC) on the inside.

Lighting and a Retractable Shelf

At this point, the fridge was ready to be tested, but for fun I decided to take the concept just a few steps further… Some lighting is nice, right? And — uh, a motorized retractable shelf for the computer! The latter turned out to be more challenging.

Basically, I used FreeCad to design a rack-and-pinion based retractable shelf. The design consists of three main parts; the rack, an old electric parabola antenna motor with a pinion, and a clamp to fix it to the shelf. Thanks to Andre Böehme for helping out with the toughest part — namely modelling the pinion and a matching rack tooth profile. I used i.materialise to 3D-print the parts. Great service!

Retractable Shelf Design

ejectTo control the position and direction of retraction of the shelf, I combined two of the relays on the external relay board to achieve a polarity reversal switch.

The parabola antenna motor also has a built-in pulse counter circuit, which can be used to pinpoint its exact angular position. Basically, the circuit sends out short square pulses synchronized with the pinions angular movement. Position control is thus achieved by simply counting pulses with an analog input channel on the Arduino.

See below for a full (sloppy) wiring diagram of the system.


Installing the Computer


I installed the computer hardware on a Lian Li test bench placed on top of the retractable shelf in the fridge.

Computer Specifications: 

  • ASUS ROG STRIX B450-E GAMING Motherboard
  • AMD Ryzen 5 2600 Wraith Stealth
  • Corsair Vengeance LPX DDR4-3200 C16 BK DC – 32GB
  • Samsung 970 EVO Plus SSD M.2 2280 – 500GB
  • ASUS GeForce RTX 2080 Ti ROG STRIX OC – 11GB GDDR6 RAM
  • Corsair 1000W PSU

Computer Fridge Code

The software I developed for the computer fridge basically consists of three parts;

  • An embedded Arduino back-end coded in C (deepfridge.ino)
  • A Python CLI frond-end to control the whole system (
Screenshot from 2019-08-09 11-47-03.png
Deep Fridge CLI
  • A set of Python test scripts with data logging functionality to conduct experiments (tests/deepfridge_logger_test*.py)

The code is available on Github:

The Computer Fridge Put at Test

Let’s run a series of tests to see if the computer fridge works. We will use the test scripts tests/deepfridge_logger_test*.py included in the Github repository. The test scripts log the following parameters to CSV files;

  • Fridge temperature  (by deepfridge.ino / Arduino DHT-11 sensor)
  • Fridge humidity (by deepfridge.ino / Arduino DHT-11 sensor)
  • CPU temperature (by calls to lmsensors / integrated CPU thermistor)
  • CPU utilization (by calls to which is based on calls to top)
  • GPU temperature (by calls to nvidia-smi / integrated GPU thermistor)
  • GPU utilization (by calls to nvidia-smi)

Some of the tests put the CPU and/or GPU to maximum utilization under certain periods — this is achieved by calls to stress and gpu-burn.

Test #1 — Computer CPU & GPU at Idle with Cooling

Description: The computer CPU & GPU is left at idle. First run for 5 minutes when the compressor is OFF to get a baseline, then the compressor is turned ON, and the logging continues for 55 minutes. Total test time is 1 hour (3600 seconds).

Test script: tests/

Log file: tests/test1.csv



Conclusion: Running the compressor for about an hour results in a CPU & GPU temperature drop of 5 degrees Celsius, when the computer is at idle. Also the ambient fridge temperature is reduced by 5 degrees Celsius.

Test #2 — Computer CPU at Maximum Utilization without Cooling

Description: The computer CPU is left at idle the first 5 minutes, and the compressor is OFF, to get a baseline. Then the computer CPU is put on maximum utilization for 5 minutes. The computer CPU is then left at idle for 5 minutes more minutes. Total test time is 15 minutes (900 seconds).

Test script:

Log file: tests/test2.csv



Conclusion: Peak CPU temperature under max utilization is at 53.7 degrees Celsius.

Test #3 — Computer CPU at Maximum Utilization with Cooling

Description: The compressor is set ON, and the computer is left at idle the first 45 minutes. Then the computer CPU is put at maximum load for 5 minutes, followed by 10 more minutes at idle. Total test time is 60 minutes (3600 seconds).

Test script:

Log file: tests/test3.csv



Conclusion: With constant cooling for about one hour & max CPU utilization for 5 minutes, again the CPU temperature is reduced by 5 degrees Celsius. Also the ambient fridge temperature is reduced by 5 degrees Celsius.

Test #4 — Computer GPU at Maximum Utilization without Cooling

Description: The computer GPU is left at idle the first 5 minutes, and the compressor is OFF, to get a baseline. Then the computer GPU is put at maximum utilization for 5 minutes. The computer GPU is then left at idle for 5 minutes more minutes. Total test time is 15 minutes (900 seconds).

Test script:

Resulting log file: test4.csv



Conclusion: Peak GPU temperature under max utilization is at 66 degrees Celsius.

Test #5 — Computer GPU at Maximum Utilization with Cooling

Description: The compressor is set ON, and the computer is left at idle the first 45 minutes. Then the computer GPU is put on maximum load for 5 minutes, followed by 10 more minutes at idle. Total test time is 60 minutes (3600 seconds).

Test script:

Log file: tests/test5.csv



Conclusion: With constant cooling for about one hour & max GPU utilization for 5 minutes, the GPU temperature is reduced by 3 degrees Celsius. The ambient fridge temperature is reduced by 4 degrees Celsius.


The tests show that there are no signs of self-heating, and that the CPU/GPU temperature drops 3-5 degrees Celsius when the cooling system has been activated for about an hour.

The ventilated computer fridge hypothesis has been confirmed!

However, is a temperature drop of 3-5 degrees Celsius worth the effort? Well, it depends. If you play around with overclocking and want to squeeze the most out of your system, 3-5 degrees Celsius might be enough. But is it really worth the effort? The system complexity is overwhelming, costly and not especially effective in its current state. However, the project was a great learning experience, and it was really fun! I doubt that I will run the cooling system much in its current state on a daily basis though.

There is plenty of room for optimization. In fact, currently I have not tested to see what happens if the cooling system remains activated for a longer period than one hour. Same is true for extended periods of maximum CPU/GPU utilization.

Please leave your thoughts in the comments section below. I am happy to receive ideas which can potentially improve the cooling performance of the system.


Device Equals ANSI Dot Sys

Click here to download the above image in android wallpaper format!

As a kid I figured out how to edit my father’s config.sys and autoexec.bat to change font colors in MS-DOS. Without the help from the internet, it was such a mysterious age where small technological discoveries were made based solely on trial and error, gossip, obscure scripts, tools and white papers spread on LAN parties and floppies.

The trick was to load the binary file ansi.sys using the DEVICE= directive in config.sys, enabling escape sequence interpretation to the standard output — which included means for changing the background and foreground font color on the command prompt.

I later installed Red Hat Linux 5.2 in 1998, but after a while I ended up compiling my own “distro” based on Linux from Scratch. My favourite nostalgic piece of memory is still my only ANSI art creation to date, namely my /etc/issue (image shown above), born based on piping and overlying Tux from Welcome2L (c) LittleIgloo.Org on a classical Windows 9x blue screen of death replica!

UPDATED 17/8-18: Added Android wallpaper version of BSOD Tux.

The Riddle

I was scanning through an old hard drive when I came across it. A large file of assembly code I had written many years ago. Its code section was tiny, but its data section huge.

Image credit:
Image credit:

It was my good old Linux audio player where the raw audio data was baked into the source itself. Or the other way around, a raw audio file with a built-in player. An interesting but sort of pathetic attempt to an executable audio file with no form of compression.

Skipping most of the data section (i.e. …), it looks like this:

; Minimalistic (or maximalistic?) Linux OSS audio player 
; by Geir K. Nilsen (2006)

dsp dd "/dev/dsp", 0
on  dd 1
fmt dd 0x00000010
sfr dd 44100
buf db 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,...

global _start 
        mov eax, 5	    ; Open DSP for read/write. System call
        mov ebx, dsp	    ; no 5. Set pointer to dsp string
        mov ecx, 02	    ; O_RDWR is defined to be 2 according
	int 0x80	    ; to asm/fcntl.h

			    ; File descriptor number now in eax.
	push eax            ; Take four copies for later system
	push eax            ; calls.
	push eax
	push eax
	push eax
			    ; OSS configuration
	mov eax, 54	    ; Set stereo, sys call ioctl is 54
	pop ebx
	mov ecx, 0xC0045003 ; See man ioctl_list, 
	mov edx, on         ; SNDCTL_DSP_STEREO
	int 0x80
	mov eax, 54	    ; Set format, 16 bit little endian
	pop ebx		    ; Format of buf is 8 bit, but 2-by-2
	mov ecx, 0xC0045005 ; samples are multiplexed to 16 bits
	mov edx, fmt        ; stereo samples.
	int 0x80

	mov eax, 54	    ; Set sampling frequency, 44100 Hz.
	pop ebx
	mov ecx, 0xC0045002
	mov edx, sfr
	int 0x80	
	mov eax, 4	    ; Prepare and write to DSP.
	pop ebx
	mov ecx, buf
	mov edx, 0x000AC440 
	int 0x80	    ; ..and play!

	mov eax, 6	    ; Close DSP. Sys call number 6.
	pop ebx
	int 0x80

	mov eax, 1	    ; Exit
	mov ebx, 0 
	int 0x80 

The file can be downloaded using the link (wait until loaded completely, then copy-paste into a plain text file):

I tried to recall what audio could be included in the file. Must boot up Linux to find the answer. Then assemble the file, and execute it. But I only have Windows on my laptop these days, so need to install it. This calls for WMware, or will it work under Cygwin? Heck, is OSS still supported by the kernel? And what assembler to use, Nasm? Or was it gas back then?

Wait, I will just parse and extract buf instead, the long string of comma-separated numbers. All the required information is provided by my comments: 16-bits samples, little endian, stereo (2 channels), sampling rate of 44100 Hz. Must be an easy job in Matlab using fscanf() and sound(). On the other hand, to recognize what will be played can turn out to be tricky. Given the file size and sampling rate, not so many audible seconds there will be. But Shazam can probably help, since I am quite sure it is a song.

I decided to challenge my team instead. They can solve my riddle outside normal working hours. Good learning for them it might be. Speaking about killing two birds with one stone.

Later the same night, me having forgotten all about the audio riddle, senior software engineer Øyvind Rørtveit sent out an e-mail containing just a short and incomprehensible sentence – “Blame it on me”. Yikes, what has he done now? I Will never blame it on you buddy, but come on, why so tight-lipped?

Øyvind is one of the best programmers I have ever known. He is like Mel,

The Story of Mel

but also with the ability to understand and translate complex mathematical concepts into working code. More about him sometime later.

I grabbed the phone and called him. I asked what was going on, and he said, “Isn’t it correct?” — “Correct what?”, I responded. “The riddle”, he said with a disappointed voice. But I was confused and struggled to find the harmony in all this.

It turned out that the brilliant riddle-maker had completely lost the solution to his own riddle, and that Øyvind had to convince him of the answer. “Yes! You are right!” — “But no, I know the answer and it isn’t this”, I said with a hint of despair, simultaneously not able to tell him the actual solution.

But he was right, and after listening to the whole song after we hung up, it again reminded me why I had chosen this song as the solution to the riddle.

Simply because the lady is a genius.