Image Processing Engineer

Fog Panther; Toronto; Hybrid; CAD 90,000 - 130,000; Full time

Job summary

Fog Panther, a small team in Toronto, is seeking a research-leaning candidate to tackle imaging problems. You will read literature, build prototypes from first principles, and decide which methods are truly suitable for our editor.

The role emphasizes understanding, derivations, and clear communication with engineering. You will prototype rapidly in Python/NumPy/SciPy, reproduce results, and explain why a chosen approach is preferred before any production code is written.

Qualifications

• Strong foundation in linear algebra, signal processing, and numerical methods.
• Background in image processing or computer vision with convolution/reconstruction knowledge.
• Ability to translate paper ideas into working prototypes.
• Prototyping fluency in Python with scientific stack; quick idea-to-demo pace.
• Comfort reading C/C++ and discussing production code with engineers.

Responsibilities

• Survey literature in denoising, sharpening, upscaling, segmentation, inpainting, and related filters.
• Reproduce published results and honestly report what holds up on real images.
• Develop new algorithms or adapt known ones; sketch proofs when needed.
• Build prototypes quickly in Python/NumPy/SciPy to answer research questions.
• Document insights, failures, and comparisons for team alignment.
• Collaborate with engineering to translate prototypes into the product and explain algorithms clearly.

Skills

Mathematics foundation

Image processing / CV background

Prototype development from papers

Python: NumPy/SciPy/scikit-image

C/C++ reading familiarity

Education

Graduate degree in a relevant field

Tools

NumPy

SciPy

scikit-image

MATLAB

Jupyter notebooks

Julia

Job description

About Fog Panther

Fog Panther is a professional desktop image editor for Linux. We build native packages for the major distributions as well as Flatpak and Snap, and we care deeply about performance, correctness, and a clean native feel on the GNOME desktop.

We are a very small team. The work is varied and the bar is high.

About the role

This is a research-leaning role. We are looking for someone whose instinct, when faced with a hard imaging problem, is to go to the literature, work the maths out on paper, build a small prototype, and prove to themselves that it actually does what they think it does — before a single line of production code gets written.

We are not looking for someone to glue together existing libraries. We are looking for someone who can read a 1998 paper on bilateral filtering, a 2014 paper on guided filters, and a 2023 paper on diffusion-based inpainting, and tell us which of the three is actually the right thing for the problem in front of us — and why.

What you'll do

• Survey the literature in the areas where we want to push the product forward: denoising, sharpening, upscaling, segmentation, masking, inpainting, healing, warping, tone mapping, colour, and the long tail of filters and adjustments that a serious image editor needs.
• Reproduce published results from scratch and report honestly on what holds up. A non-trivial fraction of the literature does not survive contact with real images, and one of your most valuable outputs will be telling us which ideas are worth our time.
• Develop new algorithms, or adapt known ones, when nothing in the literature quite fits. Derive what needs deriving. Sketch a proof when a proof is what's called for.
• Build prototypes in whatever is fastest — Python, NumPy, SciPy, Julia, MATLAB, Jupyter notebooks. The goal of a prototype is to answer a question, not to ship.
• Write up what you learn. Internal notes, derivations, comparisons, failure cases, perceptual evaluations. Future-you and the rest of the team will need to understand why the algorithm we shipped is the one we shipped.
• Work alongside engineering to land your prototypes in the product. You do not have to write the final production code yourself, but you should be able to explain the algorithm clearly enough that someone else can, and you should care whether the shipped version still does what your prototype did.
• Build small test harnesses, golden-image suites, and perceptual metrics so we can tell when a change is actually an improvement and not just a different kind of wrong.

What we're looking for

Required:

• A real foundation in the maths: linear algebra, signal processing, numerical methods, basic optimisation, a bit of statistics and probability. You should be comfortable reading a paper with equations in it and arguing about what they mean rather than skimming to the results table.
• Image processing or computer vision background. Convolution, frequency domain, sampling and reconstruction, interpolation, edge-aware filtering, colour science, gradient-domain methods, variational formulations — these should be familiar territory, not things you would have to look up to use.
• A track record of going from a paper or a problem to a working prototype on your own. Course projects, a thesis, a research role, a side project, an open notebook — we don't care about the venue, we care that you've done it.
• Prototyping fluency in Python with the scientific stack (NumPy, SciPy, scikit-image, matplotlib), or a comparable environment (Julia, MATLAB). You can go from idea to working demonstration in a day, not a week.
• Reading-level comfort with C or C++. You don't need to be a systems programmer on day one, but you should be able to follow what production code is doing and discuss changes to it with engineering.
• Honesty about what works. We would much rather hear "I tried this and it doesn't reproduce" than ship something fragile.

Nice to have (any of these):

• A graduate degree in a relevant field, or equivalent self-taught depth. We do not require one. We do require the depth.
• Published work in image processing, computer vision, computer graphics, or applied mathematics.
• ICC colour management and applied colour science.
• Classical computer vision: feature detection, segmentation, optical flow, image registration, structure from motion, inpainting, matting.
• Modern learned methods (denoising, super-resolution, segmentation, matting, inpainting), with a clear-eyed view of when they earn their cost on a desktop machine and when a classical method is the right answer.
• Production C or C++ experience.
• SIMD (SSE/AVX/NEON), threading, or GPU compute (OpenCL, CUDA, compute shaders) for image processing.
• Photography, retouching, illustration, or another hands-on creative practice. People who use the tools tend to design better ones.

How we work

• Small team, direct communication, no process theatre.
• Research and engineering sit at the same table. We don't hand prototypes over a wall — we walk them across the room.
• We prototype in whatever language gets us the answer, then port the parts that need to be fast.
• We do not use AI-generated code or text we haven't read and stand behind.
• We document non-obvious decisions so the next person understands why.

Practical details

• Location: on-site in Toronto, Canada. This is not a remote role. You must already be authorised to work in Canada — we are not able to sponsor visas.
• Compensation: competitive, depends on experience. Tell us what you need.
• Start date: flexible.