daltonlens.org

What is DaltonLens?

DaltonLens is a project that provides software and technical writing about color blindness (color vision deficiency). It has two sides: practical desktop tools for everyday use, and code, simulators and articles for people who need to understand or reproduce accurate color-blindness simulations.

What it offers

• DaltonLens for Desktop — a tray program for macOS, Windows and Linux. A global shortcut (Ctrl+Alt+Win+Space) brings it up; it can show the color under the pointer, capture a screen area and apply color filters to it, and highlight pixels with similar colors. That last feature is aimed at reading color-coded charts and plots.
• Online Color Blindness Simulator — a browser tool for comparing simulation methods, using predefined images or your own uploads.
• DaltonLens-Python — a toolbox for research and development on color vision deficiency algorithms, including simulators, Ishihara-like plate generation and confusion-line visualization. The site's technical posts are produced as Jupyter notebooks with it.
• libDaltonLens — a single-file, public-domain C library implementing reference simulation algorithms, designed to be copied or adapted.

Who it is for

The desktop utility suits a color-blind user who wants quick, on-screen help: checking an exact pixel color, filtering a chart, or finding regions that share a similar color. The simulator, Python toolbox and C library suit developers, researchers and designers who need to verify that a simulation is accurate before shipping it in an app, visualization or accessibility check.

A practical distinction

If your goal is to use color information day to day, the desktop app is the direct route. If your goal is to build or validate simulation code, the technical posts and libraries matter more, because the site's stated concern is that many available simulation programs are inaccurate. A designer auditing a dashboard's color palette, for example, would get more value from the comparison article and simulator than from the tray tool.

Next step

Start with the desktop app if you want immediate help reading charts and colors on screen; start with the "Review of Open Source Color Blindness Simulations" if you are choosing an algorithm or code to reuse. Related official resources: GitHub for the source code, and DaltonLens for the simulator and articles.

How can I simulate color blindness on my own images online?

Use a browser-based color-blindness simulator that applies a perceptual model to an uploaded image, then compare the result against the original. DaltonLens offers exactly that: an online simulator that lets you use predefined images or upload your own, and it is built on the project's own Python implementations rather than an arbitrary filter. DaltonLens

A practical workflow

1. Test with a representative image. A chart, map or UI screenshot is more informative than a photo, because color-coded categories are where confusion shows up.
2. Check several types. Protanopia, deuteranopia and tritanopia produce different failures. Red–green distinctions dominate most discussions, but tritanopia needs a different simulation pipeline and can reveal blue–yellow problems that simpler tools miss.
3. Compare side by side. Ask whether two colors that looked distinct now look the same. If they do, the image needs a second cue such as labels, patterns or direct value annotations.
4. Try severity levels. Full dichromacy is a useful worst case, but many people have partial deficiency. Seeing a mild simulation can tell you whether a design is marginal or clearly broken.

Choosing a simulator

DaltonLens also publishes a review of open-source simulations and a technical explanation of LMS-based methods, which is useful if you want to know why two simulators disagree. DaltonLens

If you only need a quick check, the online simulator is the fastest route. If you need to simulate many images or embed the transform in a design pipeline, the project's Python toolbox and its single-file C library are better suited than repeated manual uploads.

Which color blindness simulation methods are accurate and trustworthy?

The most trustworthy methods are the physiologically based models: Brettel–Viénot–Mollon (often split into Viénot 1999 for protanopia/deuteranopia and Brettel 1997 for tritanopia), plus LMS-based variants derived from them. Simple single-matrix "red-green swap" filters and naive hue-rotation filters are the least trustworthy, because they ignore how cone responses actually change.

What to trust, and why

• Brettel–Viénot–Mollon family: Uses LMS cone space and handles tritanopia with a piecewise (two-plane) projection. DaltonLens's own technical writing treats this as the state of the art, and its SVG-filter article explains why tritanopia cannot be done with one matrix. DaltonLens
• Viénot 1999 simplification: Fine for protanopia and deuteranopia, where a single matrix is a good approximation. Not sufficient on its own for tritanopia.
• LMS-based simulations generally: More accurate than RGB-space approximations because they model missing or shifted cone responses rather than just shifting colors.
• Machado et al. 2009: A widely used severity-graded model; useful when you want mild/moderate/severe variants, but it is an empirical fit rather than a direct physiological projection.
• Simple matrix filters (grayscale, hue rotation, "colorblind mode" shaders): Fast and easy to implement, but usually inaccurate. They are fine for a rough preview, not for research or accessibility testing.

How to judge a simulation you find

A practical next step

If you need to verify a simulation, compare its output against a reference implementation on the same test images. DaltonLens publishes a browser-based simulator built on its Python implementations, alongside a review of open-source simulations that flags which ones are inaccurate. DaltonLens If you are writing code, the same project offers a single-file C library of reference algorithms you can copy and adapt, and a Python toolbox for generating test plates and confusion-line visualizations. DaltonLens

For a concrete case: if you are building an accessibility feature for a charting app, test it with a Brettel-based tritanopia simulation, not a hue-rotation filter—otherwise blue-yellow deficiencies will look fine in your preview but remain unreadable for real users.

How do I install and use DaltonLens on Windows, macOS, or Linux?

DaltonLens offers a desktop utility for all three platforms, plus browser-based and developer tools. The desktop app is the main thing to install if you want everyday help; the simulator and code libraries are for testing or building your own tools.

Desktop utility

DaltonLens for Desktop is the installable app. It runs in the system tray and is meant to stay running so you can trigger it with a global shortcut (Ctrl+Alt+Win+Space) rather than launching it each time.

What it does once installed:

• Shows the color information under your pointer.
• Captures a screen area and applies color filters to that capture.
• Highlights pixels with similar colors, which is useful for reading color-coded charts and plots.

Installation routes listed on the site:

• Windows 10: via the Windows 10 App Store link.
• Older Windows versions: a separate download.
• macOS: via the Mac App Store link.
• Linux: a direct download.

The site also points to the source code on GitHub for those who prefer to build or inspect it. The most recent version noted on the page is v2.5 (January 26, 2025).

Practical steps: install the app for your platform, then check that the global shortcut works and that the tray icon is visible. If the shortcut conflicts with another app, change it in the app's settings if available. Keep it running in the background so it is ready when a chart or color-coded interface appears.

Online simulator and developer tools

If you do not want to install anything, the Online Color Blindness Simulator runs in the browser. You can use its predefined images or upload your own. It is built on the same implementations as DaltonLens-Python.

For development and research:

• DaltonLens-Python is a toolbox for color vision deficiency algorithms, including simulators and tools to generate Ishihara-like plates and visualize confusion lines.
• libDaltonLens is a single-file, public-domain C library implementing reference simulation algorithms, meant to be copied or adapted.

Choosing what to install

A useful next step: start with the desktop app if your goal is practical day-to-day use, and use the browser simulator first if you only want to test how an image or design looks under different color vision deficiencies.

How can I read color-coded charts and plots if I am color blind?

For color-coded charts, the practical problem is usually distinguishing a specific value from its neighbors, not seeing the chart at all. Two approaches work well together: inspect the exact color under your pointer, and temporarily remap the colors so the distinctions become visible.

Inspect instead of guess

DaltonLens describes a desktop utility for macOS, Windows and Linux that runs in the tray and can be summoned with a global shortcut. It can show the color information under the pointer, capture a screen area, apply a range of color filters to it, and highlight pixels with similar colors. That last feature is the one aimed squarely at color-coded charts and plots: rather than asking whether two lines are "the same green," you click one and see which other pixels match it.

A concrete workflow for a line chart with six similar series:

1. Hover over the legend swatch for the series you care about and note the color.
2. Use the similar-color highlight to see which parts of the plot match it, so crossings and overlaps stop being ambiguous.
3. If two series remain hard to separate, capture that region and cycle through filters until they diverge.
4. Read values off the axes rather than judging relative position by hue.

Remap the colors when inspection is too slow

If you need to read many charts quickly, filtering the whole image is faster than checking pixel by pixel. The trade-off is that filters change the image globally, so colors that were already distinguishable can collapse together, and any color-based annotation in the chart becomes unreliable. Inspection keeps the original colors intact but is slower per data point. Use filters for a first pass and inspection to confirm anything that matters.

Check the chart before trusting it

Simulation tools describe what a chart looks like to a given type of color vision, which is useful when you are the one producing the chart. DaltonLens offers a browser-based simulator with predefined or uploaded images, and its review of open-source simulation methods notes that many available programs are inaccurate — so a chart that "looks fine" in one simulator may not be fine in reality. If you make charts for others, testing with a trustworthy simulator plus redundant encoding (direct labels, distinct line styles, ordered lightness) removes the problem at the source.

When to reach for something else

These tools help you interpret an existing image. They do not change the underlying data, so if a chart encodes meaning in hue alone with no labels or legend text, no filter can recover information that was never printed. In that case, ask the author for the data table or a labeled version — that is faster and more reliable than any workaround.

Can I use DaltonLens-Python or libDaltonLens in my own research or software?

Yes. Both the DaltonLens-Python toolbox and the libDaltonLens C library are published as source code for reuse, and the site describes libDaltonLens specifically as a single-file, public-domain C library "meant to be easily copied/adapted." DaltonLens-Python is described as a toolbox for research and development on color vision deficiency algorithms, so it fits experimentation, simulation comparisons and generating figures or Ishihara-like plates.

H3 Practical fit

• Research and prototyping: DaltonLens-Python is the natural choice if you work in Python/Jupyter, need multiple simulator implementations, confusion-line visualizations or Ishihara-style test images.
• Embedding in C/C++ software: libDaltonLens is the lighter option: one file, public domain, designed to be dropped into a project and adapted.
• Desktop utility, not a library: DaltonLens for Desktop is an end-user tray program for macOS, Windows and Linux (color readout under the pointer, screen-area capture, filters, similar-color highlighting). It is useful for checking your own charts, but it is not the component you would link into another application.

H3 What to verify before relying on it

The site's own technical posts stress that many color-blindness simulations are inaccurate. If your research depends on a particular model (for example Viénot, Brettel & Mollon, or LMS-based approaches), check which algorithm each implementation uses and how it handles tritanopia, which the site notes needs a more careful pipeline than protanopia or deuteranopia. The browser-based simulator at DaltonLens is a quick way to compare methods visually before committing code.

A sensible next step: clone the repositories from the links on the site, run the Python implementations against your own test images, and confirm that the specific algorithm and severity model match your study design. If you only need a C implementation, start with libDaltonLens and adapt the single file rather than pulling in the full Python stack.