Web developer · Designer · Photographer

Scott
DeVore

25 years of design, photography, video production, and web development behind every build.

Sites that
do the work.

Clean functional websites that work for you and make you look good.

The lab.

Hardware, software, firmware. Things to solve little problems and make people happy.

Are you a hardware expert or financial investor?

Amoeba render: a three-lobed black cover with a brass lever and polarizing glass

Amoeba exploded view: cover glass, three polarizers, brass gear train, housing and keeper plate

Amoeba fitted over the camera island of a phone

Close-up of the one-piece brass lever and its slot

Concept · Mechanical design

Amoeba

A geared Circular Polarizer Filter (CPL) for the iPhone 17/18 Pro Max camera system.

37 × 38 mm · 4.3 mm thick · 3 polarizers · 1 leverConcept stage; nothing built yet. Not affiliated with or endorsed by Apple. iPhone is a trademark of Apple Inc.

static void motion_task(void *arg)
{
    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
    TickType_t last = xTaskGetTickCount();
    motion_out_t out = {0};
    for (;;) {
        vTaskDelayUntil(&last, 1);
        motion_in_t in;
        in.now_us = esp_timer_get_time();
        io_enc_read(&in.raw, &in.last_edge_us, &in.illegal);
        supply_sample(&s_supply, io_vin_read(), out.duty != 0.0f);
        in.vin = s_supply.vin;
        in.supply = s_supply.state;
        in.temp_c = s_temp;
        LOCK_M();
        motion_step(&s_motion, &in, &out);
        UNLOCK_M();
        io_motor_set(out.duty, out.brake);
        esp_task_wdt_reset();
    }
}


static void show_task(void *arg)
{
    ESP_ERROR_CHECK(esp_task_wdt_add(NULL));
    TickType_t last = xTaskGetTickCount();
    uint32_t tick = 0;
    bool have_next = false, has_last = false, has_prev = false;
    jl1_jump_t next = {0}, last_jump = {0};
    rgb8_t prev_color = {0, 0, 0};
    uint16_t rev_seen = 0xFFFF;
    bool running_seen = false;
    int64_t epoch_seen = 0;
    static show_state_t sh;  // ~400 bytes: keep it off the task stack

    for (;;) {
        vTaskDelayUntil(&last, pdMS_TO_TICKS(10));
        tick++;
        int64_t now = esp_timer_get_time();
        if (tick % 100 == 1) s_temp = io_temp_read();

        fixture_get_show(&sh);
        const jl1_scene_t *sc = &sh.scene;
        int id = g_fix.id;
        int idx, n;
        bool member = scene_member(sc, id, &idx, &n);
        const jl1_prog_t *prog = member ? scene_prog_of(sc, id) : &sc->prog[0];
        int64_t t_ms = (now - sh.epoch_local_us) / 1000;
        if (sh.rev != rev_seen || sh.running != running_seen || llabs(sh.epoch_local_us - epoch_seen) > 20000) {
            have_next = false;

JL-1 fixture: a cylindrical housing on a ground stake with a carbon rod

Render of the JL-1 circuit board, ESP32-C3 side

Render of the JL-1 circuit board, motor side

JL-1 phone app showing ten fixtures and show modes

Hardware · Firmware · Web app

Jumping Light

Hardware and software come together to create a magical jumping light effect for your outdoor holiday decor. All controlled from your phone.

const highBin = Math.min(binForFreq(CRICKET_HIGH), freqBinCount - 1);

let sum = 0, count = 0, maxInBand = 0;
for (let i = lowBin; i <= highBin; i++) {
  sum += dataArray[i];
  if (dataArray[i] > maxInBand) maxInBand = dataArray[i];
  count++;
}
const bandAvg = count ? sum / count : 0;
const rawLevel = Math.min(100, (((bandAvg * 0.3 + maxInBand * 0.7) / 255) * 100) * gain);

smoothedLevel += (rawLevel - smoothedLevel) * 0.25;
rollingAvg += (rawLevel - rollingAvg) * 0.02;

if (smoothedLevel > peakLevel) {
  peakLevel = smoothedLevel;
  peakDecayTimer = 90;
} else if (peakDecayTimer > 0) {
  peakDecayTimer--;
} else {
  peakLevel *= 0.995;
}

const now = performance.now();
const threshold = rollingAvg + 12;
const aboveNow = smoothedLevel > threshold && smoothedLevel > 8;
if (aboveNow && !lastAboveThreshold) {
  chirpTimestamps.push(now);
}
lastAboveThreshold = aboveNow;
chirpTimestamps = chirpTimestamps.filter(t => now - t < 4000);
const chirpsPerSec = chirpTimestamps.length / 4;

reading.textContent = Math.round(smoothedLevel);
const offset = RING_CIRCUMFERENCE * (1 - smoothedLevel / 100);
ringValue.setAttribute('stroke-dashoffset', offset.toFixed(1));
const color = colorForLevel(smoothedLevel);
ringValue.setAttribute('stroke', color);
statusPill.style.color = color;
statusText.textContent = aboveNow ? 'Chirp detected' : 'Listening';

peakHeldEl.textContent = Math.round(peakLevel) + '%';
chirpRateEl.textContent = chirpsPerSec > 0.15 ? chirpsPerSec.toFixed(1) + '/s' : '\u2014';

history.push(smoothedLevel);
if (history.length > 45) history.shift();
if (history.length >= 20) {
  const recentAvg = history.slice(-8).reduce((a,b)=>a+b,0) / 8;
  const earlierAvg = history.slice(0,8).reduce((a,b)=>a+b,0) / 8;
  const delta = recentAvg - earlierAvg;
  if (delta > 4) trendText.textContent = 'Getting warmer';
  else if (delta < -4) trendText.textContent = 'Getting colder';
  else trendText.textContent = smoothedLevel > 55 ? 'You are close' : 'Keep moving';
}

drawSpectrum();
rafId = requestAnimationFrame(loop);
  }

Web app · Audio

Cricket Finder

Listen and zero in on that annoying cricket in your house.

import Foundation

/// A 3D LUT. `data` holds RGB triplets with red varying fastest, then green, then blue (the .cube order).
public struct LUT3D: Equatable, Sendable {
    public var size: Int
    public var data: [Float]
    public var domainMin = Vec3(0, 0, 0)
    public var domainMax = Vec3(1, 1, 1)
    public var title: String = ""

    public init(size: Int, data: [Float]) {
        precondition(data.count == size * size * size * 3)
        self.size = size; self.data = data
    }

    public static func identity(size: Int) -> LUT3D { bake(size: size) { $0 } }

    /// Evaluate `f` at every grid point.
    public static func bake(size n: Int, _ f: (Vec3) -> Vec3) -> LUT3D {
        var d = [Float](repeating: 0, count: n * n * n * 3)
        let s = 1.0 / Double(n - 1)
        var i = 0
        for b in 0..<n { for g in 0..<n { for r in 0..<n {
            let o = f(Vec3(Double(r) * s, Double(g) * s, Double(b) * s))
            d[i] = Float(o.x); d[i + 1] = Float(o.y); d[i + 2] = Float(o.z); i += 3
        } } }
        return LUT3D(size: n, data: d)
    }

    @inline(__always) private func at(_ r: Int, _ g: Int, _ b: Int) -> Vec3 {
        let i = ((b * size + g) * size + r) * 3
        return Vec3(Double(data[i]), Double(data[i + 1]), Double(data[i + 2]))
    }

    /// Tetrahedral interpolation (the method Resolve uses).
    public func sample(_ v: Vec3) -> Vec3 {
        let m = Double(size - 1)
        func coord(_ x: Double, _ lo: Double, _ hi: Double) -> (Int, Double) {
            let t = min(max((x - lo) / (hi - lo), 0), 1) * m
            let i = min(Int(t), size - 2)
            return (i, t - Double(i))
        }
        let (r0, fr) = coord(v.x, domainMin.x, domainMax.x)
        let (g0, fg) = coord(v.y, domainMin.y, domainMax.y)
        let (b0, fb) = coord(v.z, domainMin.z, domainMax.z)
        let c000 = at(r0, g0, b0), c111 = at(r0 + 1, g0 + 1, b0 + 1)
        if fr > fg {
            if fg > fb {
                let c100 = at(r0 + 1, g0, b0), c110 = at(r0 + 1, g0 + 1, b0)
                return c000 * (1 - fr) + c100 * (fr - fg) + c110 * (fg - fb) + c111 * fb

Macro photograph of a camera lens element

QuickLUT on the Mac: side-by-side source and graded footage with exposure controls

Mac · iPhone · Colour

QuickLUT

Build camera LUTs for Apple Log footage, preview the grade live, and export .cube files and graded clips.

import Foundation
import CoreMediaIO
import CoreMedia
import CoreVideo

/// Pushes frames into the Camera Extension's sink stream (the extension republishes them as the "DSLR Connect" camera).
final class SinkSender {
    static let deviceUID = "D51C0A11-7B3E-4F52-9C1A-0E5D2B5D3001"
    static let sinkName = "DSLR Connect.Sink"

    private let lock = NSLock()
    private var deviceID: CMIODeviceID = 0
    private var streamID: CMIOStreamID = 0
    private var queue: CMSimpleQueue?
    private var lastAttempt = Date.distantPast
    private var failedEnqueues = 0
    private var loggedMissing = false
    private var loggedFirstSend = false

    /// Lets CoreMediaIO deliver device add/remove notifications to this process, so a camera extension that is
    /// installed or approved while the app is running shows up without restarting the app.
    static func enableDeviceNotifications() {
        var a = address(0x726E6C70) // kCMIOHardwarePropertyRunLoop ('rnlp')
        var runLoop = CFRunLoopGetMain()
        let st = CMIOObjectSetPropertyData(CMIOObjectID(kCMIOObjectSystemObject), &a, 0, nil,
                                           UInt32(MemoryLayout<CFRunLoop?>.size), &runLoop)
        if st != noErr { logLine("sink: could not set CoreMediaIO run loop (\(st))") }
    }

    private var loggedViewerFormat = false

    /// How many apps are currently reading the camera, or nil if that can't be determined.
    func viewerCount() -> Int? {
        lock.lock(); defer { lock.unlock() }
        guard queue != nil else { return nil }
        var a = Self.address(0x76777273)  // 'vwrs'
        guard CMIOObjectHasProperty(deviceID, &a) else { return nil }
        var size: UInt32 = 0
        guard CMIOObjectGetPropertyDataSize(deviceID, &a, 0, nil, &size) == noErr, size >= 4 else { return nil }
        var buf = [UInt8](repeating: 0, count: Int(size))
        var used: UInt32 = 0
        guard CMIOObjectGetPropertyData(deviceID, &a, 0, nil, size, &used, &buf) == noErr else { return nil }