How to Build and Use a Compound Eye Visual Simulation
The idea of "The Man With The Compound Eyes" usually comes up when people are trying to understand how insects perceive their environment, or when visual artists and researchers want to simulate that kind of vision digitally. It is not a single downloadable tool. It is more of a framework you build yourself depending on what you need. I have spent more time than I care to admit working with compound eye vision simulations, mostly for visual art projects and some experimental photography work. The core concept is straightforward: compound eyes, like those found in flies or bees, are made up of hundreds or thousands of individual lenses called ommatidia. Each one captures a tiny portion of the visual field, and together they create a mosaic-like image. The result is low resolution but extremely wide angle and highly sensitive to motion.
The Man With The Compound Eyes as a Concept and Practice
When I first started working on this, I assumed there was a simple plugin or app I could just download and run. There is not. What exists are a handful of research tools, some Unity shaders, and a few Blender add-ons. Most of them are either academic prototypes or unfinished. The practical approach is to assemble your own pipeline. Here is what actually works if you want to generate a compound eye view of a scene or photograph: Start with a 360-degree spherical photograph or a captured environment map. These are the foundation because a compound eye does not have a single focal point. You need omnidirectional data. I usually pull these from a Garmin Rally or an Insta360 camera, though any decent 360 rig will do. Processing time for a single high-resolution 360 photo through a compound eye shader is roughly 20 to 40 minutes on a modern GPU, depending on the number of ommatidia you simulate.
Next, you need the mapping layer. This is where most people get stuck. The geometry of a compound eye requires you to project a spherical surface onto a curved hemispherical grid. In Blender, you can use a modified refraction shader combined with a displaced sphere. The trick is that you do not want realistic insect anatomy. You want the optical effect. Set the sphere displacement to create a bumpy, faceted surface, then apply a Fresnel-based refraction with a low index of refraction. Render from inside the sphere looking outward. The output looks like a distorted mosaic, which is close to the effect. For higher fidelity, the better route is using a dedicated shader. There is an open-source Unity shader called CompoundEyeShader that some developers share on GitHub. It is not maintained anymore, but it still works for basic use. The catch is that it runs at about 30 frames per second on a mid-range GPU when simulating 500+ ommatidia. If you push past 1,000, performance drops significantly and the visual output starts to clip at the edges. That edge-clipping is a well-known limitation. I solved it by using a secondary render pass that fills in the peripheral blind spots with a lowered resolution copy of the main image. It is not perfect but it closes the gap enough for most applications. If you are doing this for still imagery rather than real-time rendering, the path is simpler. Use a tool like Hugin or PTGui to create the equirectangular projection from your source images, then run it through a Python script that applies a hexagonal grid distortion. I wrote a basic script using OpenCV and NumPy that maps each pixel to a hexagonal lattice coordinate. It takes about three minutes to process a single 8K equirectangular image. The output is a flat rectangular image that approximates how a fly would see the world: lots of overlapping low-detail sectors with the center being somewhat clearer than the edges.
Get the Full Details
There is a subtle detail most tutorials miss. Real compound eyes do not produce a uniform mosaic. The central region, called the fovea or area centralis in many insects, has higher density of ommatidia. The periphery is much coarser. If you apply a uniform hexagonal grid across your entire image, it will look wrong. You need to vary the grid density based on distance from the center. I calculate this by assigning a radial gradient to the grid resolution, tapering from about 6 pixels per hexagon in the center to roughly 24 pixels per hexagon at the edges. This single adjustment makes the output look dramatically more authentic. Another common pitfall is ignoring the spectral sensitivity of insect vision. Many insects see into the ultraviolet range and have different cone types than humans. If your source image is standard RGB and you want an accurate simulation, you need to convert it to a tristimulus space that accounts for UV response. This is rarely done in casual implementations. I use a simple matrix conversion based on the CIE 1931 color space adjusted for Drosophila melanogaster spectral sensitivity, which is one of the best-documented models. The colors come out shift-toned but in a way that is close to what a fly would actually perceive. For people who want a ready-made solution without building this from scratch, the closest thing available is the EyeSim project on GitHub. It is a Python-based toolkit that handles the spherical projection, hexagonal mapping, and spectral conversion in one package. Installation is straightforward with pip. The documentation is sparse but the examples work out of the box. I have used version 0.4.2, which is the latest as of my last check. It does not support real-time rendering, so it is mainly useful for generating still images and video frames.
The biggest limitation of every approach I have tried is resolution. Compound eye simulation inherently reduces detail because each ommatidium covers a relatively large angular sector. Even with an 8K source image, the output will never look sharp. This is not a bug. It is the nature of the biology you are simulating. If you need high resolution, you are simulating the wrong thing. Accept the low fidelity or use the output as a stylistic effect rather than a scientific visualization. A second limitation is computational cost. Real-time simulation at anything beyond a few hundred ommatidia is not practical on consumer hardware. The research community has gotten around this with GPU-based ray marching approaches, but those require custom shader programming knowledge. For most people, offline rendering is the only viable path. If you just want to see what compound eye vision looks like without building anything, there are a few interactive demos online. The Wellcome Collection in London had a web-based simulation a while back, and the Smithsonian has archived educational pages with similar tools. They are not as customizable as a build-your-own setup but they give you a solid baseline understanding of the visual effect.
The bottom line is that "The Man With The Compound Eyes" is not a product you download. It is a way of seeing that you construct through a combination of 360-degree imaging, spherical mapping, hexagonal grid distortion, and spectral color adjustment. The pipeline takes about an hour to set up properly if you are doing it for the first time. After that, a single image takes under five minutes to render. The results are striking but intentionally rough. That roughness is the point.
