How I built a local-first AI video search for macOS (leveraging CoreML & Neural Engine)

Igor Yusupov — Sat, 09 May 2026 18:59:34 +0000

Many of us have to manage massive amounts of media stored on our computers or external hard drives. To stop wasting time hunting for specific files, I built Invenio: an app that uses local AI to transform any folder of videos and photos into an instantly searchable library.

Just type a description – and find the exact moment.

I have terabytes of raw footage, and I was tired of two things: 1. Manually tagging files. 2. Privacy concerns with uploading my life to the cloud. I wanted to see if I could make Apple's Neural Engine do the heavy lifting locally.

The Tech Behind It 🛠:

Stack: Swift & SwiftUI for a fully native macOS experience.
AI Engine: Integrated CoreML to run models directly on the user's hardware.
Optimization: Heavily optimized for Apple Silicon (M1/M2/M3) using the Apple Neural Engine to keep indexing fast without draining the battery.
Privacy: Since it’s all local, there is no vector data sent to any 3rd party servers.

What Invenio can do:

Semantic Search: "red Range Rover," "bride smiling at a wedding," "drone shot of a forest" – it understands objects, actions, moods, and brands. No manual tagging required.
Find moments in long videos: It identifies the exact timecode of the scene you’re looking for.
Speech Search (Pro): Finds the specific moment where a particular phrase was spoken.
Drag & Drop: Move files directly into Premiere, Final Cut, DaVinci Resolve, and other editors.
Menu Bar App: Always within reach with a minimalist, native design.

Why it’s great for Mac:

100% Local and Private: Nothing ever leaves your device or goes to the cloud.
Optimized for Apple Silicon: Search results appear instantly.
Efficient Indexing: Fast indexing of large libraries that takes up only a few megabytes on your disk.
Fully native macOS app with a minimalist Apple design.

Unlike other services, Invenio works 100% locally and private with zero data collection. At the same time, the search is faster and more accurate because the models are optimized specifically for Apple Silicon.

Pro features are available via subscription or a Lifetime license. Specifically for dev.to community – the code DEVTO49 gives you Lifetime access for just $49 🎁 . This offer is limited to the first 500 activations.

Redeem the code

Download Invenio on the App Store

I’d love to hear your feedback! I’m actively gathering opinions right now, and your input can directly influence the app's development – I’m happy to add the features you want to see. I’m also curious to hear how this app solves your specific workflow problems. Thanks!

I’m curious to hear your thoughts:

Do you prefer local-first tools for your privacy, or do you still find cloud-based AI services more convenient?
Are you currently using any AI tools in your video/photo workflow, or is it still mostly manual sorting?

Let’s discuss in the comments!

Follow me on X/Twitter:

x.com

How to Replace OOP in Rust?

Igor Yusupov — Fri, 26 Jul 2024 21:15:19 +0000

Introduction

First, let's recall the main principles of OOP:

Inheritance
Encapsulation
Polymorphism

While there are no issues with encapsulation in Rust, developers who have worked with OOP languages like Python might face difficulties implementing the remaining principles. This is especially relevant for those who decided to rewrite a project from a language like Python/Kotlin to Rust.

Inheritance

What is inheritance? Inheritance is a mechanism that allows extending and overriding the functionality of a type. Let's look at each idea separately.

Extending Functionality

Let's consider an example in Python.

class Employee:
    def __init__(self, name: str) -> None:
        self.name = name

    def say_name(self) -> None:
        print(self.name)


class Programmer(Employee):
    pass


if __name__ == "__main__":
    programmer = Programmer("Jack")
    programmer.say_name()

Extension means that the child class will have all the functionality of the parent. However, this is easily addressed with composition. How would it look in Rust:

struct Employee {
    name: String,
}

impl Employee {
    fn say_name(&self) {
        println!("{}", self.name);
    }
}

struct Programmer {
    employee: Employee,
}

impl Programmer {
    fn say_name(&self) {
        self.employee.say_name();
    }
}

fn main() {
    let programmer = Programmer {
        employee: Employee {
            name: "Jack".to_string(),
        },
    };
    programmer.say_name();
}

It may seem that there is some code duplication here. However, the key advantage is that the child object doesn't need to inherit all the functionality from the parent, thus avoiding the creation of superclasses. Moreover, Rust has crates that minimize code duplication.

Overriding Functionality

Let's look at another example in Python

from abc import ABC, abstractmethod


class Employee(ABC):
    @abstractmethod
    def work(self) -> None:
        pass


class Programmer(Employee):
    def work(self) -> None:
        print("*coding...*")


class ProductManager(Employee):
    def work(self) -> None:
        print("*doing nothing*")


if __name__ == "__main__":
    programmer = Programmer()
    product_manager = ProductManager()

    programmer.work()
    product_manager.work()

I intentionally made the Employee class abstract. This is one of the interesting features in Python, allowing you to create something akin to interfaces for child classes.

In Rust, this is solved more elegantly with traits. Let's see how it would look in Rust:

struct Programmer {}

struct ProductManager {}

trait Employee {
    fn work(&self);
}

impl Employee for Programmer {
    fn work(&self) {
        println!("*coding...*");
    }
}

impl Employee for ProductManager {
    fn work(&self) {
        println!("*doing nothing*");
    }
}

fn main() {
    let programmer = Programmer {};
    let product_manager = ProductManager {};

    programmer.work();
    product_manager.work();
}

Additionally, traits can have default implementations for functions to avoid code duplication if the same behavior is needed for multiple structures.
Defining functionality through interfaces is also more elegant because there's no need to inherit all the functionality again. You can assign functionality "pointwise" to different structures, and a single structure can implement multiple different traits.

Polymorphism

Let's first define what polymorphism is. Polymorphism is a mechanism where a function or structure can work with different data types that implement a common interface.

In Python, this is done quite easily, just specify the base class as the type of the object (although given that you can pass anything as an argument, you might not even need to do this 😅):

from abc import ABC, abstractmethod


class Employee(ABC):
    @abstractmethod
    def work(self) -> None:
        pass


class Programmer(Employee):
    def work(self) -> None:
        print("*coding...*")


class ProductManager(Employee):
    def work(self) -> None:
        print("*doing nothing*")


def make_work(worker: Employee):
    worker.work()


if __name__ == "__main__":
    programmer = Programmer()
    product_manager = ProductManager()

    make_work(programmer)
    make_work(product_manager)

In Rust, there are several ways to achieve this. I will talk about the two most commonly used methods.
For virtual calls in Rust, there is a special mechanism using the dyn keyword. How would this code look in Rust:

struct Programmer {}

struct ProductManager {}

trait Employee {
    fn work(&self);
}

impl Employee for Programmer {
    fn work(&self) {
        println!("*coding...*");
    }
}

impl Employee for ProductManager {
    fn work(&self) {
        println!("*doing nothing*");
    }
}

fn make_work(worker: Box<dyn Employee>) {
    worker.work();
}

fn main() {
    let programmer = Programmer {};
    let product_manager = ProductManager {};

    make_work(Box::new(programmer));
    make_work(Box::new(product_manager));
}

But this is not the only way. By avoiding pointer indirection, we can achieve better performance. To avoid this, we can use enum.
Performance is higher in this case as it uses simple pattern matching instead of pointer indirection. Let's look at an example:

enum Employee {
    Programmer,
    ProductManager,
}

impl Employee {
    fn work(&self) {
        match *self {
            Employee::Programmer => println!("*coding...*"),
            Employee::ProductManager => println!("*doing nothing*"),
        }
    }
}

fn make_work(worker: Employee) {
    worker.work();
}

fn main() {
    let programmer = Employee::Programmer;
    let product_manager = Employee::ProductManager;

    make_work(programmer);
    make_work(product_manager);
}

Conclusion

Rust has all the necessary tools to rewrite an old project that was written using OOP principles. Moreover, if you use traits correctly, the result will be much more elegant. Additionally, inheritance in OOP can be a bad pattern as child classes often inherit attributes and methods that they don't use.

DEV Community: Igor Yusupov