VAULT-TEC AIR TERMINAL

Greetings Everyone and Welcome to the wasteland.

Meet the all-new Vault-Tec Air Terminal, my twist on terminals from the Fallout games. It's a fully working Ubuntu-driven computer powered by a Raspberry Pi 5, paired with an M.2 HAT.

The Fallout twist here is the addition of a secondary monitor that displays the room’s air-quality TVOC readings, presented as RADS, similar to radiation readings in Fallout. This secondary display is a TTGO T-Display ESP32-S3 Long, featuring an ultra-wide 640x180 pixel screen, which shows real-time room air-quality data measured using an SGP40 air-quality sensor.

To make the build feel different and unique, we used a Square 4-inch waveshare HDMI display as the main screen, running a retro-styled terminal interface that closely resembles an actual Fallout terminal. This interface is an Ubuntu application called Cool-Retro-Term.

For the enclosure, we designed and 3D-printed the body, then painted and weathered it with artificial rust and mold patina. Small details such as knobs, logos, and surface greebles were added to make the terminal feel authentic, like a real piece of hardware from the Fallout world.

This Instructables covers the complete build process of the Vault-Tec Air Terminal, from hardware and electronics to finishing and detailing.

So, let’s get started with the build.

These were the components used in this project:

1. Raspberry Pi 5
2. M.2 PCIE Hat
3. M.2 NVME SSD
4. Waveshare 4-Inch HDMI Square Display
5. TTGO T Display S3 Long
6. 3D Printed parts
7. DC STEP DOWN MODULE 5V 8A
8. SGP40 Probe
9. DC Barrel Jack
10. Automotive Filler
11. Red Oxide primer
12. Sanding Equipment
13. Beige Spray Paint
14. Acrylic paint Brown and Green for Patina
15. Acrylic Clear Coat Spray

Here’s how the Vault-Tec Air Terminal’s air quality meter works. On the backside of the terminal, I have added an SGP40 sensor housed inside a PG7 connector–based probe. The sensor continuously monitors the room’s air quality. Under normal conditions, my room’s air quality typically ranges between 50 and 100, which is displayed on the secondary screen.

The UI is designed to replicate a Fallout-style aesthetic, using bar indicators and text labeled RADS as an homage to the Fallout universe. To demonstrate changes in TVOC levels, I lit an incense stick and placed it near the sensor. This significantly increased the TVOC concentration, which could be seen immediately as higher numerical readings and corresponding increases in the on-screen bars.

The Fallout franchise is a retro-futuristic, post-apocalyptic RPG universe that mixes 1950s sci-fi optimism with the harsh reality of nuclear fallout. My entry point into the series was Fallout: New Vegas, and it immediately set the standard for me with its writing, atmosphere, and freedom of choice.

One of the things that fascinated me most about Fallout is how differently technology evolved compared to our real world. In this universe, transistors were never widely adopted. Instead, technological progress continued to revolve around 1950s-era vacuum tube technology, even as society believed it had reached an advanced future. This single divergence shaped nearly every aspect of the Fallout world.

This is especially visible in Fallout’s computer terminals. They were never designed to be comfortable or visually appealing. Instead, they are purely functional machines, built for control, logging, and authorization. Interacting with them feels deliberate, using a physical keyboard to unlock doors, control turrets, access security systems, or read archived corporate and government communications.

Most of these terminals were developed by RobCo Industries, founded by Robert House, who also plays a major antagonistic role in New Vegas.

Physically, Fallout terminals feel imposing. Thick metal casings, exposed vents, mechanical switches and knobs, and the constant glow and flicker of CRT screens emphasize their electro-mechanical nature. They feel more like industrial control panels than consumer electronics. Even centuries after the nuclear war, many of these terminals still function, which suggests that while vacuum tube technology is inefficient and power-hungry, it is also incredibly resilient.

For me, these terminals are more than just gameplay mechanics. They act as storytelling devices, preserving fragments of the pre-war world. Reading emails, error logs, and security notices reveals corporate greed, government paranoia, and small, human moments frozen in time, often making the terminals feel like quiet witnesses to a world that no longer exists.

For this project, I wanted to break away from the usual rectangular screens, so I went with a unique 4-inch square HDMI display from Waveshare.

It features a 4-inch IPS panel with a hardware resolution of 720x720, paired with 5-point capacitive touch and a toughened glass panel rated up to 6H hardness. When used with a Raspberry Pi, the display supports Raspberry Pi OS and Ubuntu and works out of the box with no configuration or driver editing required.

The display can also function as a standard computer monitor, supporting Windows over HDMI.

It includes an onboard dual touch circuit with optional USB Type-C or I²C touch interfaces, allowing it to be used across a wide range of application scenarios.

In addition, the display provides a 3.5 mm audio jack and speaker interface, as it supports HDMI audio output, making it suitable for compact all-in-one builds without the need for external audio hardware.

https://www.waveshare.com/4inch-hdmi-lcd-c.htm?&aff_id=Arnov

You can check out more about this display from its wiki page.

https://www.waveshare.com/wiki/4inch_HDMI_LCD_(C)

Special thanks to Waveshare for providing the hardware used in this project. The 4-Inch HDMI Square Display and supporting accessories were supplied as review units for testing and evaluation.

Waveshare is a leading global provider of electronic components, modules, and development tools used across robotics, IoT, automation, education, and many other fields. With a strong focus on quality, reliability, and continuous innovation, Waveshare has earned the trust of engineers, designers, hobbyists, and makers worldwide.

Their extensive product lineup, from displays and HATs to expansion boards and embedded modules, makes them a go-to choice for both professional builds and DIY projects.

The brain of our terminal is a Raspberry Pi 5 (4 GB RAM variant). I selected the Pi 5 because of its compact form factor and improved performance. It is powered by the Broadcom BCM2712 quad-core Arm Cortex-A76 processor, which makes it a highly usable single-board computer.

To make the system even faster and more practical, I paired the Raspberry Pi 5 with the official Raspberry Pi M.2 HAT, fitted with a 256 GB M.2 Gen 3 NVMe SSD. Ubuntu is flashed directly onto the NVMe drive, and since the operating system runs from the M.2 storage instead of a microSD card, the overall setup feels significantly faster and more responsive.

For the secondary display, we are using not a proper display but the TTGO T-Display S3 Long board, an ESP32-based development board that has a unique display. It is powered by an ESP32-S3R8 dual-core LX7 microprocessor and provides strong performance for demanding applications.

It has Bluetooth Mesh, BLE 5, and Wi-Fi 802.11. It can easily handle complex graphics and multitasking thanks to its 16 MB of flash and 8 MB of PSRAM.

Its most notable feature is the 3.4-inch capacitive touch TFT LCD, which uses a QSPI interface and has a 180 × 640 RGB pixel resolution, making it ideal for touch-enabled, long displays.

We use this board to pair the SGP40 sensor via the TTGO board’s I2C pins, connecting to the SGP40 I2C through a CON4 connector present on the back side of the board. The readings are then displayed on the 180 × 640 screen.

The Waveshare 4-inch display contains four mounting standoffs on which we can mount the Raspberry Pi 5. We positioned the Pi’s mounting holes over the standoffs and then used M2 PCB standoffs to mount the Pi in place.

Next, we positioned the M.2 HAT over the PCB standoffs and secured the M.2 HAT to the Raspberry Pi 5 using four M2 bolts.

The FPC cable that came with the M.2 HAT was then connected, with one end plugged into the PCIe connector on the Raspberry Pi 5 and the other end into the PCIe connector on the M.2 HAT.

Finally, we connected the HDMI bridge connector that came with the Waveshare display, pairing the HDMI port of the Raspberry Pi 5 with the HDMI port of the display.

One of the features of the Waveshare display is its power-sharing capability: we only need to provide power through its USB port, which powers both the Raspberry Pi 5 and the display.

Doing thorough research on the design of several terminals from the Fallout universe, we studied the design language and the key elements that make a terminal stand out (one of these features being the screen border that resembles CRT monitor bezels).

We then created our own version, starting with several rough sketches. This entire process of ideation was crucial, as we were not copy-pasting an existing terminal model but designing our own version tailored to our hardware.

Our design uses a square display as the main screen and a second display to show air-quality readings. and after experimenting with multiple design directions, we finally settled on the one we liked the most.

I started the 3D modeling process by importing the Raspberry Pi display setup along with the TTGO T-Display 3D model into my design. From there, I followed my design idea and began sketching out the enclosure. I modeled the main body first, making sure to include cutouts for the main square display and the TTGO T-Display board on the front side.

Next, I designed border frames for both the main and secondary displays. The idea was to make the screens look like old CRT-style monitors with thick display borders. These border frames were designed as separate parts so they could be 3D printed individually and then pressure-fitted into place.

From the inside, I added ribs that help keep both the TTGO T-Display and the Raspberry Pi display setup in place. Since there was very little space, I didn’t make any custom screen holders.

Instead, my idea was to use a small amount of hot glue to secure everything—an approach I got inspiration for from James’s channel and his amazing (yet crazy) Xbox handheld build.

The ribs prevent the hardware from shifting, and the hot glue permanently secures the components in place.

I modeled an extra-large knob on the right side of the main body. This knob is pressure-fitted into position.

On the front face, I added a Vault-Tec logo, which is secured in place using four M2 screws. Slightly above the Vault-Tec logo, I placed a small knob-like part that I modeled purely for aesthetics. This part is printed in red to help it stand out visually.

Next is the main lid, which serves multiple purposes. It holds the SGP40 sensor on the back side, includes a cutout for the DC barrel jack, and also acts as the enclosure lid itself. The lid has six mounting holes, allowing it to be secured to the main body using six M2 screws.

The Raspberry Pi has a status indicator LED that turns green from red once the Pi boots. To make this visible, I designed a small opening on the right side of the body aligned with this LED. A diffuser part, printed in transparent PLA, is placed in this opening so the LED glow diffuses through it and becomes visible from the outside.

Above the large knob on the right side, I added a Vault 101 logo. This logo is purely aesthetic and is secured in place using superglue.

On the left side, slightly near the I/O opening, I added a ROBCO logo, which is also secured using superglue. Below the ROBCO logo, I added a speaker grill. This grill holds the speaker in place, and both the speaker and grill assembly are pressure-fitted into the main body. From the outside, the grill sits slightly flush with the body, giving it a clean, integrated look.

I exported all the component mesh files and started the 3D printing process by printing the main enclosure first. I used the Anycubic slicer for this. To add more strength, I increased the default infill from 15% to 25% and changed the infill type to gyroid. I went with a 0.16 mm layer height using normal infill in Snug style and printed the body using grey Hyper PLA. The color didn’t really matter here since the entire body was going to be painted later.

Using the same settings, I 3D printed the lid and both display frames in black Hyper PLA.

These were the main structural parts. The remaining pieces were greeble parts, which I modeled purely to improve the overall aesthetics.

I started with the Fallout Vault-Tec logo for the front side, printing it using the same settings and grey Hyper PLA.

Next, I printed the RobCo logo and the Vault 101 logo using the same settings but with a slightly different approach. Both logos were printed in grey Hyper PLA, and halfway through the print, I paused it, swapped the grey filament with black Hyper PLA, and resumed printing.

This way, the lettering on both logos came out in black, which makes them look much bolder.

After that, I printed the front knob part using red PLA with the same settings as the previous prints.

The side knob was printed in black Hyper PLA, along with the speaker Grill.

Now comes the Filler process in which I used an automotive two-part filler, mixed it according to the recommended ratio, and applied it over the entire body.

The idea was to fill small gaps between parts and smooth out any uneven areas.

I spread the filler generously across the main body to achieve a clean, uniform surface ready for paint.

Next comes the sanding process.

For this, I used a few sheets of sandpaper, along with a sandpaper holder and a dust mask, which is a must-have for this step.

I began by sanding each face of the main body one by one. The goal here was to even out the surface by sanding down the filler. This removes excess filler and leaves a clean, smooth surface ready for the next stage.

After sanding, the next step for me was getting the body ready for paint. Since no paint job is complete without a proper base, I applied a red oxide primer to the enclosure. Using a 30 mm wide brush, I coated the entire exterior—starting with the top, then moving to the left and right sides, followed by the front, and finally the bottom.

I let the primer dry for 4–5 hours, then came back with 120-grit sandpaper. Using my sanding setup, I sanded the whole body, wiped away the dust with a damp cloth, let it dry, and sanded again.

After that, I inspected the surface for any gaps or uneven areas, applied more primer where needed, let it dry for another 4–5 hours, and repeated the sanding process.

By repeating this cycle three times, I was able to get a smooth, uniform surface that was finally ready for the paint stage.

PS: I made the job harder by using primer from a paint can. I’d recommend using a spray primer instead, as it makes the process much quicker and easier, with a more even finish.

Using a beige aerosol spray, I began the painting process by spraying evenly on each face of the main body. I intentionally applied light coats, as applying too much paint at once can cause drips, which would ruin the finish. After the first coat, I let the body dry for about 3 hours before applying a second coat.

In total, two coats were applied, resulting in a clean, smooth beige finish that gives the terminal a classic, retro look.

Now comes the crucial part that transforms the terminal from a clean, modern-looking computer into a retro, war-torn terminal—the weathering process.

I began by using a piece of sandpaper to wear down the edges and borders of the main body, along with randomly sanding a few areas on the left and right sides as well.

For the patina, I primarily used two acrylic paint colors: brown to imitate rust and green to imitate mold. I applied brown paint to the edges and areas that were sanded earlier, then used a sponge to spread it out. The paint settles into the scratches made by the sandpaper, creating a natural rusty effect.

I repeated the same process with green paint, applying it randomly across the surface and spreading it with a sponge. As the paint seeps into the scratches, the green color effectively imitates mold growth.

After this step, the body takes on an old, beaten-down appearance with a convincingly rusty and moldy look.

To keep the patina look permanent, I used an acrylic clear coat spray and applied it evenly over the entire main body. I then let it dry for 3–4 hours.

Here as well, light coats are important, since applying too much clear coat at once can cause drips and ruin the finish.

The end result is a heavily weathered, rusty-looking body that is fully sealed with a clear coat, making the finish durable and long-lasting.

Next is the screen frame assembly process. I first placed the frame for the TTGO T-Display board into position from the front of the main body.

After that, I installed the main square display frame. Both frame parts are pressure-fitted into place.

Next, the Vault-Tec logo is positioned above its mounting location on the front side of the main body and secured in place using four M2 screws.

1. Superglue is applied to the backside of the front knob part and it is positioned slightly above the Vault-Tec logo.
2. Similarly, I applied superglue to the back of the Vault 101 part and positioned it on the left side of the main body.
3. I then added superglue to the back of the RobCo Industries logo and positioned it on the right side of the main body.
4. Finally, the knob is installed on the left side of the main body. This knob was pressure-fitted into place, completing the main body assembly process.

For the air quality meter setup, I connected the I2C pins of the SGP40 sensor directly to the I2C connector of the TTGO T-Display board. This allowed the ESP32 to communicate with the sensor using the standard SDA and SCL lines.

Once the hardware connections were completed, I uploaded the main sketch to the TTGO T-Display board.

Below is the main code used for this setup.

In our code, I used customised Display driver AXS15231B, this has been done as the display I am using isn't a normal standard arduino compatable TFT display, our edited display driver allows the TTGo board to work with existing stuff completely.

similarly, I have added the fullFont custom bitmap font file that contains 5x7 bitmap fonts, we are using this as we are not using any graphical library like adafruit gfx so we need to manually draw pixels into the framebuffer.

Here's a small breakdown of the rest of the code.

Display Configuration

We first define Resolution of display. I also added frameBuffer which is a full-screen off-screen buffer.

Color Definitions

Colors are in RGB565 format and we have used only two colors, which are black for the background and yellow for the terminal fallout theme.

SGP40 Sensor Variables

I next added SGP40 variables in which vocRaw is the direct sensor reading, vocSmooth filters the value basically reducing noise and vocDisplay is the value shown on screen.

Startup Animation State

Here’s a fun feature I added: on startup, the display shows a bar animation where the bars move from bottom to top before any data is displayed. This animation runs once when the ESP32 receives power from the power source, giving the terminal a proper boot-up feel.

Display is physically rotated; hence, we needed a function that rotates the framebuffer 90 degrees. basically this sends data column by column instead of row by row.

Framebuffer Utilities

This clears the screen to black.

Using the above function, this manually fills pixels in the framebuffer; this is our primitive drawing function.

Font Rendering

This reads bitmap data from the fontFull.h file, rotates characters 90 degrees, support scaling and writes directly to the framebuffer.

This stack rotates characters vertically and it is used for numeric values.

Bar Graph Logic

This section converts VOC values into 10 Bar levels.

Using this function, we clear the bar area, calculate bar size and spacing, and then draw only the active bars based on VOC values.

RADS Panel Rendering

This function draws a bordered panel inside, where there is a RADS label and even displays VOC Values below the RADS.

Main Loop

This reads the raw VOC index.

This reduces noise while remaining responsive.

Peak-hold logic

I have added the AXS15231B.h and .cpp files along with the fontFull.h file, which you need to put in the same folder as the .ino file.

For the demo run, I used an incense stick to increase the VOC levels through smoke release. As the VOC concentration rises, the displayed readings increase, and the number of bars on the screen increases accordingly.

To power the Raspberry Pi, display, and ESP32 from a single supply, we used a high-current DC buck converter module.

Specifically, we chose a 6-USB Output DC Step-Down Module capable of converting 8V–40V DC input down to a regulated 5V output at up to 8A.

The module accepts power through a DC barrel jack, allowing the use of a wide range of adapters, including 12V, 24V, or even 36V supplies. This makes the power system flexible and easy to adapt to different setups. The regulated 5V output is distributed through six onboard USB ports, enabling multiple devices to be powered simultaneously without the need for separate regulators.

For power, I wanted to use a 12 V 4 A power adapter with a DC barrel jack male connector. To connect it to the DC step-down module, I soldered a DC barrel jack female connector, wiring its positive and negative terminals to the input ports of the DC step-down module.

For power distribution between the Raspberry Pi–display setup and the TTGO T-Display board, I used two short USB Type-C cables, which power both setups reliably without any soldering. While I could have soldered these connections directly, using Type-C cables was simply quicker and more convenient.

The protective covering from the main display was removed, and the entire Raspberry Pi display setup was then slid down into its position.

Using a small amount of hot glue, the Raspberry Pi display setup was secured in place.

Next, the TTGO T- DISPLAY Board was positioned in its mounting position in the correct orientation, hotglue was used to secure it in its place.

Next is the speaker assembly. I used M2 nuts and bolts to secure the speaker grill to the 4-ohm speaker mounting holes.

The entire speaker grill assembly was then slid into its position from the inside of the main body, where it is pressure-fitted in place.

Finally, I connected the speaker’s CON2 connector to the audio connector on the Waveshare display.

The lid assembly starts by first installing the SGP40 sensor. The PG7 connector nut was unscrewed, the sensor wire was passed through the hole in the lid, and the nut was then tightened to secure the SGP40 in place.

Next, the DC barrel jack was inserted into its mounting position, and the retaining nut was tightened to firmly secure it.

The DC step-down module is placed over its mounting position and then fastened in place using two M2 PCB standoffs and M2 bolts.

After that, the DC barrel connector’s positive and negative wires are re-soldered to the input terminals of the DC step-down module.

With this, the lid assembly process is complete, and we can now begin the final assembly process.

The final assembly process begins by connecting the SGP40 wiring to the TTGO I²C connector.

Next, the USB Type-C port from the Waveshare display is plugged into one of the USB ports on the DC step-down module, along with the TTGO Type-C port, which is also connected to the DC step-down module.

The LED diffuser is then placed into position using a tweezer. This diffuser is pressure-fitted and snaps securely into place.

Once all the connections are done, the lid is placed on the backside of the main body in its position.

Six M2 screws are then used to fasten the lid to the main body. With this, the entire project is complete, and the terminal build is finished.

The end result of this super sick project is a terminal that looks like it came straight out of the Fallout universe. It contains a Raspberry Pi 5 paired with an M.2 HAT, which makes it a quite capable setup. The entire design is custom; I did thorough research on Fallout terminals and came up with my own design by following Fallout’s terminal design language.

The display is also not a usual one. I used a very unique Waveshare 4-inch square display, which makes the setup feel more retro, similar to old 4:3 TVs from earlier times. I also worked on the body finish, where I painted the enclosure and added patina and aesthetic greeble parts.

On the backside, there is an SGP40 sensor that reads and monitors indoor air quality (TVOC levels). These readings are displayed on the secondary display and labeled as RADS, as a homage to Fallout radiation readings. I also added 10 bars that increase or decrease depending on the RADS value—more bars appear as the reading increases, with a maximum of 10 bars and a minimum of 1.

This is a perfect Pi-based computer that also monitors indoor air quality. The only thing missing is a keyboard, which most terminals usually have. My goal was to make a smaller terminal, and adding a keyboard to such a compact design would have looked odd, which is why I didn’t include one. Maybe in Version 2 of this project, I’ll build a more powerful all-in-one computer—larger than this version—and include a keyboard along with more sensors and additional Fallout-related features.

For now, this project is complete, and all the files related to it are attached in this article. Feel free to reach out if you need any information or help regarding the project, and let me know what things you think I could have done differently.

I’ve made a few similar Fallout-themed projects as well. If you’re into the Fallout universe, feel free to check them out.

https://www.instructables.com/PIP-WATCH/

https://www.instructables.com/PiP-WATCH-Project/

This is it for now and i'll be back with a new project real soon. peace!