# Iris by Mohtasham Murshid Madani [Canonical page](https://www.mohtasham.dev/work/iris) A free, open-source iPhone camera for people who want manual control over their photographs. Iris is planned as an offline iPhone still camera with automatic and manual controls, hardware-derived ranges, live Looks, HEIC or JPEG capture, DNG, and a Photo Lab. The current work is an Expo SDK 57 interface prototype and a public browser simulation, not a released camera app. Role: Creator. Updated 2026-08-26. I started Iris because the manual camera apps I found for iPhone were expensive. Paying for another app or subscription should not be the only way to control shutter speed, ISO, focus, white balance, exposure, and RAW capture. Iris is my attempt to build a free alternative. The first release is planned as an iPhone still camera with automatic capture when you want it and full manual controls when you do not. I designed and built the current prototype alone. Its interface takes inspiration from Halide 3, but Iris uses its own branding, controls, icons, and visual system. ## My work - Product design - Interface design - Development ## Current build - Expo SDK 57 prototype - Browser demo - No released camera app ## First release - Free and open source - iPhone stills - Offline without an account ## Why I want it to be open source Open-source software is how I learned much of what I know about building products. I could inspect real projects, understand how they worked, change things, break them, and try again. Iris should offer that same opportunity to someone else. The app will be free and open source. It is for anyone who wants more control over an iPhone photograph without paying for a professional camera app. Someone should be able to use it as a simple automatic camera, then move into shutter speed, ISO, manual focus, white balance, exposure compensation, zoom, and DNG capture as they learn. ## What works in the prototype The mobile app is currently an interactive interface prototype. It has Auto and Manual modes, control dials, RAW and aspect-ratio controls, composition guides, zoom shortcuts, haptics, a Look selector, and Photo Lab editing screens. It does not yet connect those controls to a production iPhone camera pipeline, and it cannot take a real photograph today. The public website has a browser demo built around a sample image. Visitors can move the focus point, change the crop, select a Look, adjust simulated exposure, and render a JPEG or PNG through canvas. I used AI to draft the current Look recipes. They are prototype starting points, not copied camera profiles, and they still need device testing so the live preview and saved photograph produce the same result. ## Turning the prototype into a camera The hardest part is the iPhone camera API. Iris uses Expo SDK 57, but the App Store version of Expo Go available when I tested it did not accept the project during the SDK transition. Expo Go is useful for interface work, but the complete manual-control and image-processing stack needs a custom Expo development build and testing on a physical iPhone. The next milestone is a signed build with camera permissions, a stable live preview, one reliable capture per shutter tap, camera switching, orientation handling, save recovery, and a recent-photo thumbnail. After a 100-shot reliability test, I can add hardware-derived manual ranges, locked controls, DNG capture, GPU-rendered Looks, and preview-to-export color checks. I plan to release Iris through TestFlight and eventually the App Store, but neither exists today. ## Planned first-release flow 1. Open the camera: Grant camera access and enter the viewfinder without an account. 2. Choose a mode: Shoot in Auto or open the manual control tray. 3. Set the photograph: Adjust focus, exposure, white balance, format, zoom, and Look. 4. Capture: Create one processed photo or supported DNG per shutter tap. 5. Review and save: Keep the original, change the Look, share, or save to Photos. ## Prototype today and the native path ahead Interface now: Expo camera shell: Modes, dials, grids, zoom, haptics, and Looks; Photo Lab: Look and editing panels around a mock image Simulation now: Viewfinder mock: Supplied image behind the mobile controls; Browser canvas: CSS preview and JPEG or PNG rendering Native foundation next: Custom Expo build: Signed development client on a physical iPhone; Camera capability report: Device formats, lenses, ISO, focus, and RAW support Capture pipeline later: Live camera preview: Capability-aware Auto and Manual controls; Processed or RAW file: HEIC or JPEG plus DNG where supported; iOS Photos: Reliable save, retry, and recent-capture review ## demo action to current behavior - tap viewfinder: Move the focus marker. The demo changes the visual focus point and crop anchor - choose a lens: Change the crop. CSS scale and canvas coordinates simulate a focal-length change - select a Look: Apply a color recipe. The same filter values feed the preview and canvas export - adjust exposure: Change brightness. A browser filter simulates the visible exposure response - choose RAW: Render a PNG. This is a demo stand-in and not real sensor DNG data - press shutter: Rasterize the sample image. Canvas produces a downloadable JPEG or PNG ## Repository ```text apps/ mobile/ # Expo interface prototype web/ # Astro product site and canvas demo docs/ # Product and contributor documentation ``` npm install && npm run mobile The camera interface and product site live in one workspace. Iris will be free and open source because open-source projects taught me how to build. I want this camera to give someone else the same chance. - [Open the product site ↗](https://iris.mohtasham.dev) - [View the source ↗](https://github.com/MohtashamMurshid/iris) [Visit Iris](https://iris.mohtasham.dev)