Building smart glasses at home is a realistic project that ranges from a simple notification display clipped to regular frames to a full augmented reality setup with camera input and object recognition. The approach you choose depends on your budget, soldering skills, and what you actually want the glasses to do. Most DIY builds fall into two categories: a basic heads-up display that shows text from your phone, or a more advanced system that overlays graphics onto your field of vision.
Decide What Your Glasses Will Do
Before buying any parts, pin down your use case. A pair of glasses that displays the time, incoming texts, and navigation arrows is a fundamentally different project from one that runs a live camera feed with object detection. The first can run on a tiny microcontroller and a small OLED screen for under $50 in parts. The second needs a single-board computer, a camera module, and a more complex optical system, pushing costs to $150 or more.
The simplest builds worth attempting show phone notifications, weather, time, and basic navigation cues on a small transparent display near one eye. This is what most first-time builders should target. It teaches you the core principles (optics, power management, wireless communication) without requiring months of work.
Core Hardware You’ll Need
Every pair of smart glasses shares the same basic architecture: a processing unit, a display, an optical system to get the image into your eye, a battery, sensors, and a frame to hold it all together.
Processing unit. For a notification-only build, the ESP32 microcontroller is the go-to choice. It has built-in Wi-Fi and Bluetooth, runs at up to 240 MHz, and sips power. In deep sleep mode it draws as little as 10 to 150 microamps, which means a small battery can last days between charges. If you need to do heavier lifting like running a camera, processing voice commands, or doing any kind of image recognition, step up to a Raspberry Pi Zero 2 W. It has a quad-core processor running at 1 GHz and runs a full Linux operating system, but it draws around 100 to 200 milliamps under typical use. That’s roughly 1,000 times more than an ESP32 in active mode, so your battery life drops significantly.
Display. Most DIY builds use a micro OLED panel, typically 0.39 to 0.96 inches diagonally. These are bright enough to read in daylight, small enough to fit near the temple or bridge of your frames, and draw minimal power. For more advanced builds, LCoS (liquid crystal on silicon) modules offer higher resolution in a compact form factor, but they cost more and require a more sophisticated optical path.
Battery. A lithium polymer cell in the 200 to 500 milliamp-hour range fits along a glasses temple. With an ESP32-based build, a 400 mAh cell can power the glasses for a full day of intermittent use. With a Pi Zero, you’ll drain that same battery in two to three hours under load.
Frame. Many builders start with a thick-framed pair of safety glasses or 3D-printed frames. The temples (the arms that hook over your ears) are where most of the electronics live: the processor on one side, the battery on the other.
Getting the Image Into Your Eye
This is the trickiest part of the build and the piece that separates a crude prototype from something genuinely usable. You need an optical system that takes the tiny image from your micro display and projects it so your eye can focus on it while still seeing the real world through the lens.
The simplest approach is called birdbath optics. Light from the display bounces off a partially reflective combiner (essentially a small piece of angled glass or a beam splitter cube) and into your eye. You can build a basic version with a micro OLED, a small beam splitter prism, and a magnifying lens, all mounted near the corner of one lens. The image appears to float a couple of feet in front of you. The downside is that the combiner blocks some of your view and the whole assembly adds bulk.
Waveguides are what commercial smart glasses use to keep the lenses thin and transparent. Light from the display enters the edge of a thin glass or plastic slab and bounces through it via total internal reflection before exiting toward your eye. Diffractive waveguides use etched surface gratings to control where light enters and exits the slab. These produce the sleekest results, but manufacturing a custom waveguide at home is essentially impossible. Some builders purchase off-the-shelf waveguide evaluation kits, though these typically cost $200 or more just for the optic.
For a first build, the beam splitter approach is the most practical. You can buy a small beam splitter cube for a few dollars and experiment with positioning until the display image is clear and in focus.
Keep the Weight Under Control
Comfort matters more than features if you plan to wear these for longer than ten minutes. Research on wearable head-mounted devices found that people start to notice added weight at around 39 grams, and they perceive a side-to-side imbalance when one temple is roughly 14 grams heavier than the other. Regular eyeglasses weigh 20 to 40 grams, so your entire electronics package needs to stay as light as possible.
Distribute weight evenly. If your processor sits on the right temple and your battery on the left, weigh each side and adjust placement until the difference stays under that 14-gram threshold. Use the lightest components you can find, and consider running wires to a belt-mounted battery pack if the on-frame weight becomes uncomfortable. 3D-printed nylon frames are lighter than most acetate frames you’d find at a store, and you can design channels for wiring directly into the print.
Connecting to Your Phone
Most smart glasses pull data from a companion app on your smartphone over Bluetooth Low Energy (BLE). The ESP32 has BLE built in. On the phone side, Android exposes Bluetooth services through its built-in BluetoothAdapter library, and iOS uses Core Bluetooth. You write a small app (or modify an open-source one) that captures notifications, GPS directions, or whatever data you want, then sends it to the glasses as short text packets.
The typical setup uses BLE “characteristics,” which are small data channels your phone writes to and your glasses read from. For example, your phone app might write the text of an incoming message to a characteristic, and the ESP32 polls that characteristic and pushes the text to the display. BLE is designed for exactly this kind of low-bandwidth, low-power communication. It won’t stream video, but it handles text, simple icons, and sensor data effortlessly.
Building the Interface
A tiny display means you need a minimal, glanceable interface. You’re not building a smartphone screen. Think single lines of text, simple icons, and high contrast (white or green on black works best on OLED panels).
For ESP32-based builds, the LVGL graphics library is the most capable free option. It’s an open-source framework with over 30 built-in interface widgets (buttons, labels, progress bars, lists) and works on microcontrollers running as slow as 100 MHz. It supports OLED and e-paper displays, handles multiple fonts and languages, and fits in a very small memory footprint. You design your layout in code, defining where each text element sits and how it updates when new data arrives over Bluetooth.
If you’re using a Raspberry Pi, you have the full Linux graphics stack available. Python with a simple framebuffer library, or even a lightweight web page rendered in a kiosk browser, can drive the display. This gives you more flexibility but uses far more power.
Battery Safety Near Your Face
Lithium polymer batteries are energy-dense and generally safe, but you’re strapping one to your temple, so take precautions seriously. Use only cells with built-in protection circuits that cut power if the battery overcharges, over-discharges, or short-circuits. Never use bare, unprotected cells.
Warning signs of a failing lithium battery include the cell getting unusually hot, swelling or bulging, leaking fluid, making hissing or popping sounds, or producing smoke or unusual odors. If you notice any of these, remove the glasses immediately and place them on a non-flammable surface away from your body. Store and charge your glasses in a cool, dry location out of direct sunlight. Using a charging pouch (a small fireproof bag designed for lithium cells) adds a layer of protection during charging.
On the thermal side, both the processor and display generate heat. In a glasses form factor there’s almost no room for heat sinks, so keeping processing loads low is the best thermal strategy. The ESP32’s deep sleep modes help here: rather than running the processor constantly, wake it only when new data arrives or the user taps a button.
A Simple First Build Step by Step
Here’s a practical starting point for a notification display using widely available parts:
- ESP32 dev board (like the ESP32-C3 SuperMini): handles Bluetooth and drives the display
- 0.42- or 0.96-inch micro OLED: connected to the ESP32 over I2C or SPI
- Small beam splitter prism or half-mirror: positions the display image in your line of sight
- Magnifying lens (around 10x): lets your eye focus on the display at close range
- 3.7V lithium polymer battery (300 to 500 mAh with protection circuit)
- 3D-printed or modified thick-frame glasses: to house everything
Wire the OLED to the ESP32, write firmware that connects to your phone over BLE and displays incoming text, then mount the display and beam splitter on the frame so the reflected image appears in the upper corner of one lens. Adjust the lens distance until the text is sharp. Tuck the ESP32 into one temple and the battery into the other. The entire electronics package can weigh under 30 grams if you use compact components and short wiring.
Start with static text (display “Hello World” on the lens) before adding Bluetooth. Once you can reliably see text through the optics, layer in phone connectivity, then notifications, then more complex data like weather or navigation. Each step builds on the last, and you’ll learn more from troubleshooting the optics and fit than from any tutorial.