Building a pair of DIY eBook reading glasses sounds simple at first: mount a tiny screen near your eye, connect it to a Raspberry Pi or microcontroller, and display a book.

The reality is considerably more interesting.

The main challenge is not displaying text. Even a modest microcontroller can render pages of an eBook. The difficult part is creating an optical system that lets your eyes see that tiny display as a sharp, comfortable virtual screen rather than as a glowing object sitting a few centimetres from your face.

That distinction is what separates a workable wearable reader from a project that produces blurry text, headaches, and eye fatigue.

Commercial devices such as the Sol Reader demonstrate how specialized the optical side of the problem becomes. The current Sol Reader uses two 1.3-inch, 271-ppi E Ink displays combined with pancake optics, adjustable interpupillary distance from 58 to 72 mm, and diopter adjustment from 0 to -5.75. The complete reader weighs approximately 104 grams.

Replicating that exact architecture at home would be difficult, particularly because tiny E Ink panels and custom pancake-optical assemblies are not commonly available as hobbyist modules.

A more realistic DIY approach is therefore to combine a Raspberry Pi or ESP32-class processor with a micro-OLED display and, most importantly, a complete near-eye optical engine.

Why You Cannot Simply Put a Screen in Front of Your Eye

A common first idea is to mount a 0.3-inch OLED a few centimetres from the eye.

Unfortunately, your eye cannot normally focus comfortably on something that close. The display may simply appear as a colored blur.

This is why VR headsets, electronic viewfinders, and smart glasses contain optics between the display and the eye.

The objective is to create a virtual image.

A lens placed at the correct distance from the micro-display transforms the light leaving its pixels so that the eye perceives the screen as being much farther away. Depending on the optical design, the virtual image might behave as though it were several metres away or effectively at optical infinity.

Mirrors and prisms can then fold the optical path so the whole mechanism fits into a compact enclosure.

This is an important distinction:

A 45-degree prism can redirect light, but it does not by itself solve the focusing problem.

A usable near-eye display normally needs some combination of:

• a micro-display,
• a collimating or magnifying lens,
• mirrors or prisms,
• a beam splitter or combiner in see-through designs,
• eye-relief control,
• an appropriately sized exit pupil.

Commercial micro-OLED optical engines already combine many of these elements. Near-eye modules are available that integrate a micro-OLED with lenses, prisms, mirrors, combiners, or folded optical structures specifically to produce a usable virtual image.

For a DIY project, buying or salvaging such an optical engine is dramatically easier than designing the optical train from individual lenses.

The Eye-Strain Problem

Eye comfort is not determined simply by whether the screen is physically close to your face.

What matters is what the optics tell your eyes to do.

Two processes are particularly important.

Accommodation is the adjustment of the eye’s lens to bring an object into focus.

Vergence is the inward or outward rotation of the two eyes required to look at an object at a particular distance.

In normal vision, these two systems generally work together. A nearby object requires both closer focus and greater convergence.

Near-eye displays can disrupt that relationship. A stereoscopic display can tell the eyes to converge on one apparent distance while its optical system requires accommodation at another. This is known as vergence-accommodation conflict, and research has linked such conflicts with visual discomfort and fatigue in head-mounted displays.

Fortunately, a dedicated eBook reader is easier than a full VR headset because it does not need to simulate objects continuously moving through 3D space. Your entire page can occupy one fixed virtual plane.

The design goal should therefore be simplicity: create one stable, sharply focused reading plane and keep the left and right optical channels properly aligned.

Choosing the Computer

There are two particularly sensible approaches for a DIY reader.

Raspberry Pi Zero 2 W

The Raspberry Pi Zero 2 W is the easier platform if you want to deal directly with EPUB files, complex fonts, Wi-Fi synchronization, Python software, or an existing Linux eBook-rendering engine.

The board contains a 1 GHz quad-core 64-bit Cortex-A53 processor, 512 MB of RAM, Wi-Fi, Bluetooth 4.2/BLE, microSD storage and HDMI output in a 65 × 30 mm board.

That makes it considerably more computer than an eBook reader actually needs.

Its main disadvantages are power consumption and physical packaging. A Zero 2 W plus display electronics, battery-management circuitry, connectors and a micro-display can make one temple of a pair of glasses unpleasantly heavy.

A sensible prototype may therefore place the Raspberry Pi in a pocket or small neck-mounted enclosure while keeping only the optical module on the glasses. Once the concept works, the electronics can be miniaturized.

ESP32-S3

For a lightweight dedicated reader, the ESP32-S3 is arguably the more interesting option.

It contains a dual-core processor running at up to 240 MHz, 512 KB of internal SRAM, Wi-Fi and Bluetooth LE. ESP32-S3 modules can also include external flash and PSRAM, and the chip provides LCD-related peripherals.

That is more than enough processing power for:

• page navigation,
• text rendering,
• font management,
• Bluetooth controls,
• brightness adjustment,
• bookmarks,
• battery monitoring,
• simple menus.

The trade-off is software complexity.

An ESP32 is not a tiny Linux computer. Full EPUB rendering involves ZIP decompression, XML/HTML parsing, CSS, Unicode text layout and font rasterization. You can implement those functions, but it is much more work than running an existing eBook engine on Linux.

A practical compromise is to preprocess books on a computer or phone and transfer already-cleaned text and layout information to the glasses.

For a first prototype, TXT files are significantly easier than EPUB.

Choosing the Display

The obvious DIY substitute for miniature E Ink is a micro-OLED.

Consumer-accessible examples now include modules around 0.23 to 0.39 inches diagonal, with resolutions ranging from 640 × 400 to 1024 × 768. Some are sold with HDMI driver boards specifically for near-eye and electronic-viewfinder applications.

For reading glasses, resolution matters more than color.

Tiny letters expose every weakness in an optical system. A display that looks impressive while showing icons can become surprisingly unpleasant when asked to reproduce several lines of small serif text.

Ideally, choose:

• the highest practical resolution,
• high contrast,
• individually controllable brightness,
• an available driver board,
• a matching optical engine.

OLED also has an advantage for a reading-oriented interface: black pixels consume little or no emissive power. A predominantly black page containing white, gray or warm-colored text can therefore be an efficient display mode.

It will not behave exactly like E Ink, but it can produce an effective low-light reading interface.

The Most Important Purchase: The Optical Engine

If there is one component on which you should avoid improvising during the first prototype, it is the optical assembly.

Instead of purchasing a bare micro-OLED and attempting to hold a random prism in front of it, look for terms such as:

• micro-OLED optical engine,
• near-eye display module,
• OLED EVF module,
• birdbath optical engine,
• pancake optical module.

Some development modules combine the micro-display, driver electronics and optical system into a single assembly. Such modules exist specifically because integrating microdisplays and near-eye optics is difficult.

Another source is an electronic viewfinder from a camera.

An EVF is effectively a tiny high-resolution display plus magnifying optics designed to be viewed with one eye. Electrically driving a salvaged EVF can be difficult, but an entire functioning EVF module can make an excellent experimental optical system.

Monocular or Binocular?

The easiest prototype uses one display.

A monocular design requires only one optical engine and eliminates the extremely precise mechanical alignment required between two displays.

It is ideal for proving:

• text readability,
• focal distance,
• font size,
• brightness,
• page navigation,
• battery life.

A binocular design is much more ambitious.

Now both eyes must receive images that are correctly positioned relative to each other. Interpupillary distance becomes important, as does vertical alignment. Even a small vertical error between the two images can make fusion uncomfortable.

Commercial products therefore provide mechanical IPD adjustment. Sol Reader, for example, specifies an adjustment range from 58 to 72 mm.

A serious binocular DIY version should also provide some method of adjusting IPD rather than permanently fixing the displays at an assumed distance.

Recommended Prototype Architecture

A workable first-generation design could look like this:

Processor: Raspberry Pi Zero 2 W

Display: 0.39-inch 1024 × 768 micro-OLED with HDMI controller

Optics: Integrated EVF or near-eye optical engine

Storage: microSD card

Controls: Bluetooth presentation remote or three to five physical buttons

Battery: Protected rechargeable LiPo pack with appropriate charger and voltage-regulation circuitry

Software: Lightweight Linux plus a custom reading interface

This version will not initially resemble normal eyeglasses.

That is fine.

Trying to make the first prototype tiny is one of the easiest ways to make the project fail. First make the optics and software work on a bench. Miniaturization should come later.

Step 1: Build the Optical Prototype Before Designing the Frame

Do not begin with CAD.

Begin with the display and optics.

Mount the optical engine on an adjustable fixture and feed it a static test pattern containing:

• large text,
• small text,
• horizontal and vertical lines,
• circles,
• checkerboards,
• characters near the display edges.

Move the optical assembly until the entire text field can be viewed comfortably.

Check whether moving your eye slightly causes parts of the image to disappear. If so, the optical system has a small usable eye box, which will make wearable alignment especially difficult.

Only after you know the required relationship between eye and optical module should you design the frame around it.

Step 2: Determine Comfortable Text Size

Do not try to reproduce a complete Kindle page immediately.

A small near-eye display may work much better with six or eight lines of text than with twenty.

Experiment with:

• font size,
• line spacing,
• line length,
• margin width,
• brightness,
• text color.

For OLED, a useful starting interface is warm white or amber-gray text on a completely black background.

Avoid maximum brightness in a dark room.

For reading, contrast should be sufficient rather than extreme.

Step 3: Add Page Rendering

The simplest reader can operate on plain UTF-8 text.

A Python prototype might:

1. Load a TXT file.
2. Wrap text according to the available display width.
3. Divide the resulting lines into pages.
4. Rasterize each page using a chosen font.
5. Display the page fullscreen.
6. Wait for a button press.
7. Move forward or backward.

Once that works reliably, EPUB support can be added.

An EPUB file is essentially a packaged collection of XHTML, CSS, images and metadata. On a Raspberry Pi, existing Python and Linux libraries can do much of the parsing work.

On an ESP32, a simpler approach is to convert the book beforehand into a custom format consisting of text chapters, bookmarks and perhaps precomputed page boundaries.

That substantially reduces CPU, RAM and software requirements on the wearable hardware.

Step 4: Add Page-Turn Controls

A reader does not need a touchscreen.

In fact, physical controls are arguably preferable because the user cannot easily see the outside of the headset while reading.

Good options include:

• Bluetooth presentation remote,
• small joystick,
• five-way navigation switch,
• two tactile buttons,
• rotary encoder.

At minimum, provide forward and back controls.

Additional buttons can handle the menu, font size and bookmarks.

Sol Reader similarly separates reading controls into a handheld remote rather than requiring constant interaction with the headset itself. Its specifications list a separate remote powered by a replaceable CR2450 battery.

A remote also prevents repeated button presses from physically disturbing optical alignment.

Step 5: Design the Frame

Only now should CAD begin.

The frame must solve several mechanical problems simultaneously:

• support the optical modules rigidly,
• position them precisely relative to the pupils,
• route electrical connections,
• distribute battery and electronics weight,
• provide ventilation,
• survive repeated handling.

Avoid putting every component on one temple.

Unequal weight quickly becomes irritating.

If two batteries are used, one can be placed on each side. Commercial designs use similar balancing strategies; Sol Reader, for example, specifies two 235 mAh internal lithium-ion batteries.

For prototypes, PETG is generally preferable to brittle materials where parts need to flex around hinges. Final versions could use nylon or another lightweight engineering polymer.

Do not treat 110 grams as a universal comfort threshold, although it is a sensible engineering target. Commercial lightweight readers provide a useful reference: the Sol Reader itself is specified at 104 grams.

Weight distribution matters almost as much as total weight.

Step 6: Add Battery Power Carefully

LiPo batteries are excellent for wearable projects because they provide substantial energy in a thin package, but they require correct charging and protection.

Use a proper lithium-battery charger and protection circuit rather than connecting a cell directly to arbitrary USB power.

The power architecture may require separate voltage rails for:

• the processor,
• micro-display,
• HDMI or display controller,
• Bluetooth peripherals.

Measure actual current consumption before choosing the final battery.

This is particularly important with a Raspberry Pi. Designing around the board’s power-supply specification rather than measuring the consumption of your actual application can produce a battery that is either unnecessarily large or disappointingly short-lived.

An ESP32-based reader will generally offer more opportunities for aggressive power optimization because the processor can sleep between user actions and does not need to maintain a full Linux operating system.

Step 7: Build Binocular Version Two

Once a single-eye reader works, duplicate the optical channel.

Do not simply connect a second screen and glue it beside the first.

The system should provide adjustment for:

• IPD,
• vertical alignment,
• focus or diopter correction if possible,
• optical-module angle.

Display the same calibration target to both eyes and adjust the modules until the images fuse naturally without the user deliberately forcing them together.

Research on head-mounted displays has repeatedly shown that mismatches between vergence and accommodation, and other binocular alignment problems, can contribute to discomfort.

If reading produces persistent headache, double vision, nausea, difficulty refocusing afterward or significant eye discomfort, stop using the prototype and correct the optical configuration rather than attempting to acclimatize yourself to it.

Why Reproducing the Sol Reader Exactly Is Much Harder

The finished commercial product provides a useful benchmark for what a refined design requires.

Sol Reader combines:

• two 1.3-inch E Ink displays,
• 271 ppi resolution,
• side lighting using 3000K LEDs,
• pancake optics,
• circular polarizers,
• transflective films,
• IPD adjustment,
• adjustable diopter correction,
• automatic light sensing,
• dual rechargeable batteries,
• dedicated remote control.

It achieves more than 25 hours of claimed reading time while keeping the reader itself to approximately 104 grams.

The difficult part of copying that device is therefore not creating an EPUB reader.

It is reproducing its custom display-and-optics system.

For a DIY builder, using a complete micro-OLED optical engine is a much more achievable compromise.

A More Practical DIY Version

If the objective is simply to read while lying down without holding a Kindle, the project does not even have to put the computer on your head.

A particularly sensible architecture is:

On the glasses: display modules and minimal electronics.

In a pocket or neck enclosure: Raspberry Pi, battery and storage.

In your hand: Bluetooth page-turn remote.

This dramatically reduces head weight while allowing a much larger battery and easier cooling.

Once the design works, you can determine which components genuinely need to move onto the frame.

Alternative Project: OCR Reading Glasses

There is another way to interpret the idea of “reading glasses.”

Instead of displaying an eBook, the glasses can read physical text to the user.

Such a system uses:

• a small camera,
• Raspberry Pi or similar computer,
• OCR software,
• text-to-speech software,
• Bluetooth or wired headphones,
• one or more control buttons.

The camera captures a page, OCR converts the photograph into machine-readable text, and a speech engine reads the resulting text aloud.

This eliminates the near-eye-display problem completely.

The engineering challenges shift instead toward:

• camera focus,
• page detection,
• lighting,
• OCR accuracy,
• text ordering,
• speech latency.

For accessibility projects, this approach may actually be more useful than attempting to recreate an optical e-reader.

It can also be built incrementally: first make a desktop OCR reader, then attach the camera to glasses, and finally shrink the computing hardware.

Which DIY Route Makes the Most Sense?

For most hobbyists, there are three sensible levels of difficulty.

Beginner: OCR/TTS glasses

Use a camera and headphones. No near-eye optics are required.

Intermediate: Monocular micro-OLED reader

Use one commercially available optical engine with a Raspberry Pi or ESP32. This proves the display, optics and reading interface without the difficulties of binocular alignment.

Advanced: Binocular eBook glasses

Use two matched optical engines, adjustable IPD, precise mechanical alignment, custom power electronics and carefully balanced frame construction.

Attempting to manufacture a miniature E Ink pancake-optical system comparable to a commercial reader would be a much more serious optical engineering project.

Final Thoughts

DIY eBook reading glasses are absolutely possible, but the project should be approached as an optics project first and an eBook project second.

A Raspberry Pi Zero 2 W can easily handle sophisticated book processing, while an ESP32-S3 can create a much smaller and more efficient dedicated reader. Both platforms have ample processing capability for displaying text.

The real bottleneck is delivering that text comfortably to the eye.

For that reason, the best first purchase is not a Raspberry Pi, a battery or a 3D printer. It is a complete near-eye optical display module.

Get one eye displaying crisp, comfortable text on the workbench. Add page turning. Read with it for a while. Only then design the glasses frame, battery system and second optical channel.

Following that order turns the project from an extremely difficult attempt to duplicate commercial smart glasses into a manageable sequence of engineering experiments.

And that is probably the most realistic path toward a genuinely usable pair of homemade eBook reading glasses.