A normal movie begs for your attention. It wants a dark room, popcorn, surround sound, and your phone face-down like it just got grounded. A Very Slow Movie Player, on the other hand, is delightfully unbothered. It takes a film, stretches it across weeks or months, and displays one carefully chosen frame at a time on an e-paper screen. Instead of “watching” a movie, you live beside it.

That already sounds charmingly strange. But the truly fascinating part is not the slowness. It is the engineering problem hiding behind the calm picture-frame exterior: how do you show a colorful, fast-changing film on a black-and-white E-Ink display without ugly ghosting? Mat Kelcey’s machine-learning-based approach to a Very Slow Movie Player shows why this tiny art object is also a clever lesson in computer vision, dithering, partial refresh, and the stubborn personality of electronic paper.

In plain English: E-Ink is wonderful at holding a static image, but it is not naturally thrilled about becoming a cinema screen. Ask it to update too often or change too many pixels, and faint leftovers from previous frames can hang around like guests who missed the part where the party ended. Kelcey’s project uses machine learning to make those frame updates smarter, cleaner, and more visually pleasing.

What Is a Very Slow Movie Player?

A Very Slow Movie Player, often shortened to VSMP, is a DIY device that displays a movie at an extremely reduced frame rate. Instead of the standard 24 frames per second, classic VSMP projects often advance at around 24 frames per hour. At that pace, a film becomes less like entertainment and more like a moving photograph, a long-form clock, or a tiny museum exhibit in your living room.

The original idea popularized by Bryan Boyer used a Raspberry Pi, custom software, and a reflective e-paper display. Every few minutes, the system extracts a frame from a stored film, processes it into a black-and-white image, and sends it to the display. The result is not a video in the normal sense. It is a patient visual experience, where a single shot can sit quietly for minutes before giving way to the next one.

That shift changes how you perceive a film. A chase scene becomes architecture. A close-up becomes a portrait. A background prop you never noticed suddenly gets its moment of glory. If regular cinema is a river, a Very Slow Movie Player is a tray of ice cubes made from that river. Same water, very different vibe.

Why E-Ink Makes the Project So Appealing

E-Ink, or electronic paper, is a natural fit for slow cinema because it behaves more like printed paper than a glowing LCD or OLED panel. It reflects ambient light instead of blasting light into your eyes, which gives it a calm, paper-like presence. Once an image is drawn, many e-paper displays can hold that image with very little power.

That is perfect for a device meant to sit on a shelf, quietly showing a film frame all day. A bright tablet would feel too much like a screen. E-Ink feels like an object. It has the mood of a framed print, but one that occasionally changes when you are not looking. Spooky? Maybe. Elegant? Absolutely.

However, E-Ink has trade-offs. Its pixels are controlled by moving charged particles, not by instantly changing light output. This makes refreshes slower than conventional displays. It also makes partial updates tricky. A full refresh can clear the screen well, but it often creates a noticeable flash. A partial refresh can be faster and less distracting, but it may leave behind faint visual residue. That residue is called E-Ink ghosting.

What Is E-Ink Ghosting?

E-Ink ghosting is the faint remnant of a previous image that remains visible after the display updates. If you have used an e-reader and seen a pale shadow of the last page after turning to the next one, you have met the ghost. It is not haunted hardware. It is the result of how electronic ink particles move and settle during refresh cycles.

For text, ghosting may be mildly annoying. For a Very Slow Movie Player, it can become a major aesthetic problem. Movie frames are rich with shadows, faces, scenery, gradients, camera movement, and sudden cuts. Even after converting everything to black and white, the screen may need to change thousands or millions of pixels between frames. On an E-Ink display, that can create visual mud.

The usual workaround is to perform a full refresh every so often. Full refreshes help reset the screen, but they can create an obvious black-white flashing effect. For an ambient art object, that flash is the equivalent of someone turning on the kitchen lights during a candlelit dinner. Technically useful, emotionally rude.

The Dithering Challenge: Turning Color Films Into Black and White Dots

Most black-and-white E-Ink displays cannot show true continuous grayscale in the same way a traditional monitor can. To create the illusion of shades, developers often use dithering. Dithering arranges black and white pixels in patterns so the human eye perceives gray tones. More black pixels in an area make it look darker; more white pixels make it look lighter.

This is an old and powerful image-processing trick. It is why newspapers, retro games, and monochrome displays can suggest depth and texture with limited color options. For a still image, a good dithering algorithm can look surprisingly beautiful. But a Very Slow Movie Player has an extra problem: it is not just processing one image. It is processing a long sequence of related images.

A traditional dithering algorithm might make each frame look good on its own while still changing far too many pixels from one frame to the next. That creates more work for the E-Ink display and increases the chance of ghosting. The better question becomes: Can we make the current frame look good while also respecting what the previous frame looked like?

How Machine Learning Helps

Mat Kelcey’s approach explored a machine-learning solution to this exact problem. His project used a high-resolution black-and-white E-Ink display and played frames from the 1979 film Alien at roughly one frame every 200 seconds. Because the movie contains dark environments, high contrast, faces, motion, and dramatic scene changes, it is a wonderfully mean test case. In other words, if your algorithm can make Alien look good on E-Ink, it has earned a small trophy and maybe a tiny astronaut helmet.

The core idea was to train a model to generate dithered frames that balanced multiple goals. First, the output should look like a good black-and-white version of the original color frame. Second, it should preserve enough fine detail to avoid becoming a blurry blob. Third, it should minimize unnecessary pixel changes from the previous frame, because fewer changes generally mean less ghosting and smoother partial refresh behavior.

Kelcey experimented with neural-network architectures inspired by image-to-image translation methods. A U-Net-style model could map color images to black-and-white dithered output, but early results tended to capture broad shapes better than fine texture. Adding a GAN-style objective helped encourage more realistic, detailed dithering. Later experiments introduced the previous frame as part of the input and added a loss term related to avoiding excessive change.

Why “Change Fewer Pixels” Is Harder Than It Sounds

At first glance, minimizing pixel changes sounds simple. Just keep as much of the old image as possible, right? Unfortunately, movies are rude. They pan, cut, fade, zoom, and occasionally replace a calm hallway with a terrifying creature that was definitely not in the previous frame.

For mostly stationary shots, preserving old pixels can work beautifully. The model can keep a stable dither pattern while gently adjusting details. But during scene cuts or camera pans, too much loyalty to the previous frame can create a visual mash-up: part new image, part old image, part “did the printer sneeze?”

Kelcey noted that scene changes produce obvious spikes in pixel differences, but panning shots can be trickier. A pan may not be a hard cut, yet it can still require many pixels to change. A simple scene-change detector may miss that case. A more practical strategy is to track the number of changed pixels since the last full redraw and trigger a reset when the accumulated change passes a threshold. That approach is less glamorous than saying “the AI solved everything,” but it is much closer to real engineering: smart model, simple rule, better result.

Partial Refresh vs. Full Refresh

Understanding this project also means understanding the tension between partial refresh and full refresh. A full refresh updates the entire display and is better at clearing artifacts, but it can be slow and visually disruptive. A partial refresh updates only what needs to change, or uses a faster mode that avoids the dramatic flashing effect. The downside is that repeated partial updates can make ghosting more visible over time.

A Very Slow Movie Player wants the best of both worlds. It wants frames to appear calmly, without the whole screen blinking like a haunted photocopier. But it also wants clean, readable images. Machine learning can help by reducing unnecessary changes, while occasional full refreshes can act as housekeeping. The magic is in knowing when to be subtle and when to wipe the slate clean.

Why This Project Matters Beyond a Niche Gadget

On the surface, a Very Slow Movie Player sounds like a delightful oddity for people who own soldering irons and have strong opinions about picture frames. But the idea has broader relevance. E-paper displays are used in e-readers, digital signage, shelf labels, badges, dashboards, industrial devices, and low-power interfaces. In all of those contexts, reducing ghosting while preserving clarity matters.

The machine-learning angle is especially interesting because it treats display limitations as part of the creative process. Instead of simply forcing a normal video pipeline onto E-Ink, the project asks what kind of image generation is appropriate for this medium. That is a healthier way to think about technology. Not every screen should behave like a television. Not every interface needs to chase 120Hz. Sometimes the better design is slower, quieter, and more intentional.

Building a VSMP: The Basic Ingredients

Most DIY Very Slow Movie Player builds share a few common ingredients: a Raspberry Pi or similar small computer, an e-paper display, display driver hardware, a memory card, a frame or enclosure, and software that extracts movie frames at a chosen interval. Tools such as FFmpeg are commonly used to open and process video files, while Python libraries can handle image conversion and communication with the display.

The hardware does not need to be exotic. Some builds use a Raspberry Pi Zero, others use larger Pi models. Displays vary by size and resolution. A 7.5-inch E-Ink panel is popular because it feels close to a small framed photograph. A higher-resolution screen can show more detail, but it also increases processing demands and makes image conversion more important.

The software pipeline usually follows a pattern: select a movie, calculate frame timing, extract a frame, resize or crop it for the display, convert it to black and white, apply dithering, and refresh the screen. Kelcey’s machine-learning experiments add a more advanced image-generation step in the middle, where the model attempts to create a dithered frame that looks good and behaves well on the actual hardware.

The Artistic Side: A Movie Becomes a Roommate

One of the most charming things about a Very Slow Movie Player is that it changes the social role of a film. A normal movie is an event. You sit down, press play, and finish it before the popcorn fully understands its destiny. A slow movie player turns that event into a long-term relationship.

Imagine 2001: A Space Odyssey taking nearly a year to unfold on a shelf. Imagine Metropolis becoming a rotating gallery of expressionist architecture. Imagine an animated film slowly revealing backgrounds, color decisions, and character poses that are normally gone in a fraction of a second. The device lets you inspect cinema instead of consuming it.

That is why E-Ink is such a good medium for the idea. It does not feel like a paused video. It feels like a print that happens to be alive. The slowness removes urgency. You do not have to keep up. You simply notice it when you pass by, like a window that occasionally changes the weather.

Lessons From the Machine-Learning Approach

1. Optimization Needs a Real-World Target

A frame that looks excellent on a laptop monitor may look terrible on E-Ink. The target medium matters. Kelcey’s experiments show that image-processing success should be judged on the actual screen, not just in a notebook, browser, or animated GIF.

2. The Best Technical Solution May Be Hybrid

Machine learning can improve dithering, but simple rules still matter. Pixel-change thresholds, cooldown periods between full redraws, and practical refresh policies can make the difference between a clever demo and a pleasant daily object.

3. Aesthetic Quality Is Not Always Measurable

One model version may score better according to a loss function, while another may simply look better on the physical display. That is not failure. That is design. Screens are viewed by humans, not spreadsheets wearing glasses.

Experience Notes: Living With a Very Slow Movie Player Concept

The first thing you learn from a Very Slow Movie Player is that slowness has texture. At normal speed, a movie tells you where to look. At ultra-slow speed, the frame asks you to decide for yourself. You start noticing negative space, set design, lighting direction, costume shapes, and the weird dignity of background furniture. A chair that appears for half a second in a film can become the star of your Tuesday afternoon.

The second lesson is that E-Ink has a personality. It is not a lazy LCD. It is its own medium, with strengths and stubborn habits. The low-power, paper-like look is beautiful, especially in daylight. But ghosting reminds you that every update is physical. The screen is not merely changing numbers; it is moving particles. That makes the device feel less like software and more like a mechanical printmaker.

Choosing the right movie also becomes surprisingly important. Bright, clean films with strong compositions often translate well. Dark, smoky, fast-cut movies are harder, but they can be more rewarding when the processing works. A slow frame from a science-fiction movie can look like concept art. A black-and-white classic can look almost native to the display. Animation can be wonderful because the compositions are often bold, but gradients and subtle color palettes need careful dithering.

The experience also changes depending on placement. On a desk, the player becomes a quiet companion. On a bookshelf, it becomes a mysterious object guests will eventually point at and ask about. In a hallway, it becomes a tiny cinematic weather report. The best location is somewhere you pass often but do not stare at continuously. A Very Slow Movie Player is terrible at demanding attention and excellent at rewarding curiosity.

From a builder’s perspective, the most satisfying part is tuning the relationship between image quality and refresh behavior. Too many full refreshes make the device feel jumpy. Too few, and ghosting builds up. Too much dithering detail can look noisy. Too little can flatten the image into a posterized soup. The sweet spot feels almost musical: enough detail to recognize the scene, enough stability to keep the screen calm, and enough surprise to make the next frame worth noticing.

That is why the machine-learning approach is so appealing. It does not just automate a task; it helps negotiate between competing goals. The model is not trying to make E-Ink act like a movie screen. It is trying to make a movie behave like E-Ink. That distinction is the whole charm of the project.

Conclusion

The Very Slow Movie Player is a beautiful reminder that innovation is not always about speed. Sometimes it is about restraint. By combining E-Ink hardware, clever dithering, Raspberry Pi software, and machine-learning experiments, projects like Mat Kelcey’s show how a film can be transformed into a living artwork that changes at the pace of a houseplant with cinematic ambitions.

More importantly, the project highlights a practical technical insight: display constraints should shape the algorithm. E-Ink ghosting is not just a flaw to complain about; it is a design challenge. Machine learning becomes useful when it respects that challenge, reducing unnecessary pixel changes while preserving the mood and detail of the original film.

In a world obsessed with faster screens, faster apps, and faster everything, the Very Slow Movie Player feels refreshingly rebellious. It asks a simple question: what if the best way to appreciate a movie is not to press play, but to let it quietly unfold in the corner of your room for months?