Miguel Piedrafita

Bringing World ID to Agents

Tue, 17 Mar 2026 21:08:31 GMT

With more and more agents browsing the internet, telling bots acting on behalf of a human apart from crawlers & other undesirable bots will become increasingly important. I've been working on using World ID to provide websites with a proof that a human is behind bot requests. It's out as a developer preview today!

Pokemon Go, but for payphones (?)

Mon, 02 Mar 2026 23:34:45 GMT

Riley Waltz recently launched a new game where you go out and hunt down California payphones. I happened to be in SF and wanted to join in on the fun, but copying directions over and over became a bit of a chore.

So I dug up an unreleased project from last year (bike app for Lisbon) and put together a simple app that lets you see your closest phones and navigate to them in one click. Check out those sick sheet animations!

View on GitHub

A brand new World ID (RFC)

Thu, 22 Jan 2026 17:27:10 GMT

It's not often you need to update a protocol. World ID has mostly stayed the same since we first designed it in 2021, and that's because it's great at doing the one thing it's supposed to do (let you anonymously prove you're a human).

Four years later, we want to give it a few extra super-powers, like allowing anyone to issue their own credentials using the protocol. We'd love to hear your feedback on the proposal!

Share your feedback

Speeding up the Cloudflare dashboard

Sun, 04 Jan 2026 19:30:14 GMT

I use Cloudflare to power a ton of things (including the video above!), but still dread having to go to the dashboard. It's soooo slow.

To make my life a bit better, I built a lil CLI tool that deep-links into specific pages, cutting down the time it takes me to get places by a ton.

View on GitHub

A game to keep up with the news

Fri, 02 Jan 2026 15:55:53 GMT

A few days ago, I found a really cool game which turns the news into simple games (trivia & letter unscrambling). Originally a web app with a really nice design, I took it as a challenge to recreate it as a native iOS app. This is the result!

Play Timelines on the web

Exploring Spotify's leaked data

Wed, 24 Dec 2025 20:01:22 GMT

Last week, a group of archivists managed to scrape a ton of data from Spotify (including user playlists and, most excitingly, music files). To explore the data (and figure out which of my favorite songs were in there), I built a website that lets you sign in with your Spotify account and navigate the dump easily.

Turning photos into 3D environments

Sun, 21 Dec 2025 01:48:34 GMT

Apple recently released an experimental ML model called sharp, which generates gaussian splatting scenes from a single image. I wanted an easier way to play with it, so I spent some time compiling the model to CoreML and building a simple macOS app to interact with it.

Decentralized gift-giving on World App

Fri, 12 Dec 2025 23:14:44 GMT

This year's holiday release of World App comes with a whimsical feature: the first global, human-only gift exchange. We put a lot of love into the experience, so it sort of feels like opening a real gift.

Try it out

Rendering Miis

Thu, 23 Oct 2025 14:42:04 GMT

The other day I stumbled upon a C++ decompilation of the Wii U library that renders Miis.

I don't have a ton of experience with C++, but after a few hours of trial and error, I managed to run it on my Mac (it needed porting from OpenGL to Metal) and update the render function to give me full-body renders instead of just heads.

A Swift SDK for Sora

Mon, 06 Oct 2025 19:36:20 GMT

import VideoAPI

let client = VideoAPI(authToken: YOUR_OPENAI_AUTH_TOKEN)

let video = try await client.create(
    prompt: "A cute cat playing with a ball of yarn",
    model: .sora2Pro
)

I was invited to OpenAI DevDay this year, where the new Sora APIs got announced. To play around with them, I built a simple Swift SDK that makes it super easy to integrate AI video generation into your iOS and macOS apps.

View on GitHub

Glass icon for an upcoming app

Tue, 23 Sep 2025 21:14:59 GMT

I've been working on an app called Pocket, which helps you manage your media server (more on that soon!). Of course, every app needs a cool icon, and I was very happy with how this one turned out.

Cleaning up my Twitter followers

Tue, 23 Sep 2025 16:44:26 GMT

One of the bad things about having a large Twitter following is that, over time, you end up with a lot of inactive or spammy accounts following you. Aside from being annoying, this was starting to make my tweets not show up on people's timelines.

To fix this, I downloaded a list of everyone that followed me, and spent a few days writing scripts to get rid of obvious bots and spammy accounts. The result? +20k less followers, and a much healthier account!

Real-time AI in two lines of code

Thu, 28 Aug 2025 18:40:34 GMT

import SwiftUI
import RealtimeAPI

struct ContentView: View {
	@State private var conversation = Conversation()

	var body: some View {
		Text("This is all you need for interactive AI in your app!")
			.task {
                try await conversation.connect(
                    ephemeralKey: YOUR_EPHEMERAL_KEY_HERE
                )
            }
	}
}

OpenAI released a new version of their Realtime API recently, so I took the chance to completely rewrite my old Swift SDK for it, massively improving performance and ergonomics.

It now uses WebRTC under the hood, which makes it way more reliable and faster than the previous WebSocket-based implementation. Check it out!

View on GitHub

A skeumorphic voice journal

Fri, 04 Jul 2025 16:36:29 GMT

A few weeks ago, my girlfriend and I challenged ourselves to make an app that didn't look or feel like an iOS app.

To achieve this, she designed the app using vector graphics instead of a UI framework, while I added haptics and other affordances to make it feel as familiar as possible. I'm obviously biased, but i think it turned out great. Try it out!

Download on the App Store

The Nintendo DS Clock, on your phone

Tue, 03 Jun 2025 16:49:58 GMT

I've been feeling a bit nostalgic for old consoles recently, with the Switch 2 finally dropping this week.

To celebrate, my girlfriend and I spent the weekend recreating the original Nintendo DS clock as an iOS widget. It's now live on the App Store!

Download on the App Store

A Swift SDK for the OpenAI Images API

Thu, 24 Apr 2025 04:34:44 GMT

import OpenAlImages

let client = ImagesAPI(authToken: OPENAI_API_KEY)

let response = try await client.create(prompt: "A cute cat")

let response = try await client.edit(
    image: .url(
        Bundle.main.url(forResource: "image", withExtension: "png"),
        format: .png
    ),
    prompt: "Change the color of the sky"
)

OpenAI finally made their latest image generation model available through the API! I'm planning to build an app that makes use of it soon, so I needed a lightweight SDK for interacting with it.

View on GitHub

A library to let AI take over your computer

Thu, 03 Apr 2025 05:15:43 GMT

let agent = Agent(model: .aceSmall, apiKey: "sk_...")
let computer = Computer()

let session = agent.start("Star the GeneralAgentsKit github repository")

var observation = try await computer.observe()
while true {
    let action = try await session plan(observation: observation)

    print("Executing: \(action)")
    if action.kind == .stop { break }

    observation = try await computer.execute(action)
}

I've been having a lot of fun playing with "Computer Use" APIs (where an AI model can issue instructions to control a computer or browser).

This week, I found a pretty promising API (by General Agents), and built a nice Swift wrapper over it that gives the AI control over your keyboard and mouse!

View on GitHub

Imagining an app that turns your friends into stickers

Fri, 28 Mar 2025 23:49:13 GMT

OpenAI just released an incredibly update to their image generation tooling, and I've had a blast playing with all the different styles.

One of my favorites was the "Sticker" style, and even though there's not an API for it yet, I thought I'd try my hand at designing how it could look like.

Making AI-powered iOS apps effortless

Fri, 21 Mar 2025 22:32:59 GMT

import OpenAI
import SwiftUI

struct ChatView: View {
	  @State var newMessage: String = ""
	  @State var conversation = Conversation(authToken: OPENAI_KEY, using: .gpt4o)

	  var body: some View {
    		VStack(spacing: 0) {
    			  ScrollView {
                VStack(spacing: 12) {
                    ForEach(conversation.messages, id: .self) { message in
                        MessageBubble(message: message)
                    }
                }
    			  }

    			  TextField("Chat", text: $newMessage)
    				    .frame(height: 40)
    				    .submitLabel(.send)
    				    .onSubmit {
    				        Task {
      			            try await conversation.send(text: newMessage)
      			            newMessage = ""
      		          }
    				    }
    		}
    		.navigationBarTitle("Chat", displayMode: .inline)
    }
}

After finishing working on the Rust SDK, I got some cool ideas of how the developer experience could look like for building AI-powered iOS apps.

This time, instead of just a wrapper over the API, the SDK comes with a Conversation utility which manages all the hard things for you.

View on GitHub

A Rust SDK for the OpenAI Responses API

Wed, 12 Mar 2025 20:30:07 GMT

use openai_responses::{Client, Request, types::{Input, Model}};

let response = Client::from_env()?.create(Request {
    model: Model::GPT4o,
    input: Input::Text("Are semicolons optional in JavaScript?".to_string()),
    instructions: Some("You are a coding assistant that talks like a pirate".to_string()),
    ..Default::default()
}).await?;

println!("{}", response.output_text());

OpenAI released a new API today to unify all of their models under a single endpoint. They released Python and JS SDKs, but I wanted one for Rust, so I spent some time knocking one out.

I'm particularly happy with the way I managed to "Rust-ify" the types to make them feel more idiomatic. Will be building some cool stuff with it soon!

View on GitHub

Disappearing Text Effect

Tue, 04 Mar 2025 01:53:49 GMT

Saw a particularly neat effect on the Devouring Details website, where your email vanishes after you subscribe to the newsletter. After playing around for a few hours, I managed to recreate it perfectly!

View on GitHub

Love or Bot

Fri, 14 Feb 2025 15:34:22 GMT

For Valentine's Day, I built a game where you are shown a bunch of photos, and need to figure out if they are real or AI-generated. It's harder than it looks, try it out!

Play on World App

React Server Actions, for PHP

Sat, 08 Feb 2025 20:44:55 GMT

import { php } from '@/lib/php' // [!code focus]
import { startTransition, useState } from 'react'

const ExamplePage = () => {
    const [email, setEmail] = useState('')
    const [password, setPassword] = useState('')
    const [response, setResponse] = useState(null)

    // [!code focus:9]
    const signIn = php`
        use Illuminate\Support\Facades\Auth;

        function (string $email, string $password) {
            Auth::attempt(['email' => $email, 'password' => $password]);

            return Auth::user() ?? response()->json(['error' => 'Invalid credentials'], 401)
        }
    `

    return (
        <div>
            <h1>Sign In</h1>
            {response && <pre>{JSON.stringify(response)}</pre>}
            <input type="email" value={email} onChange={e => setEmail(e.target.value)} />
            <input type="password" value={password} onChange={e => setPassword(e.target.value)} />
            <button
                onClick={() => // [!code focus]
                    startTransition(async () => signIn(email, password).then(response => setResponse(response))) // [!code focus]
                } // [!code focus]
            >Log In</button>
        </div>
    )
}

export default ExamplePage

I recently saw Fusion, a PHP package that lets you write PHP directly inside of Vue components. Inspired by it, I thought I'd try my hand at a React version.

It's a work in progress, but it works! You define PHP functions inside of JS and call them like regular JS functions. I even got syntax highlighting working in VSCode!

View on GitHub

A lightweight pipeline system for Swift.

Mon, 03 Feb 2025 13:44:55 GMT

import Pipeline;

try Pipeline.send(project).through(
    .pipe(BuildProject(),
    .pipe(UploadProject(),
    .pipe(DeployProject()),
    .fn { project in
        // ...

        return project
    }
))).run()

I recently attended LaraconEU, where I watched a talk going over all the things that Laravel's relatively-simple Pipeline class makes so much easier. It felt like the kind of thing that could come in handy in the future, so I thought I'd quickly build a Swift version.

View on GitHub

A simple Swift library for watching over your Mac

Mon, 27 Jan 2025 03:48:49 GMT

import AppKit
import WatchEye
import Foundation

class ExampleWatchEyeDelegate {
	let watchEye: WatchEye

	init() {
		watchEye = WatchEye()
		watchEye.delegate = self
	}
}

extension ExampleWatchEyeDelegate: WatchEyeDelegate {
	func watchEyeDidReceiveAccessibilityPermissions(_: WatchEye) {
        print("Accessibility permissions granted!")
    }

	func watchEye(_: WatchEye, didFocusApplication app: NSRunningApplication) {
        print("(app.bundleIdentifier!) is now in focus")
    }

	func watchEye(_: WatchEye, didChangeTitleOf app: NSRunningApplication, newTitle title: String) {
        if app.browser?.isIncognito(windowTitle: title) == true { return }

		print("Title of (app.bundleIdentifier!) changed to (title)")

        if let url = app.browser?.getURL() {
			print("URL of (app.bundleIdentifier!) is now (url)")
		}
	}
}

For an upcoming macOS app I've been working on, I needed a way to watch over other apps while on the background. You can do this with the Accessibility API, but it is quite complicated to set up.

I built a lil helper class for my app, and thought I'd also release it as a library for others to use.

View on GitHub

A nice SwiftUI landing screen

Thu, 26 Dec 2024 07:23:25 GMT

Thought I'd build a very simple HomeKit controller app during Christmas, then spent most of the time building the first splash screen for the app instead of the actual app. looks pretty nice tho!

Making OpenAI's new APIs production-ready

Tue, 01 Oct 2024 22:10:02 GMT

use axum::{extract::WebSocketUpgrade, response::IntoResponse, routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/ws", get(ws_handler));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn ws_handler(ws: WebSocketUpgrade) -> impl IntoResponse {
    // check for authentication/access/etc. here

    let proxy = realtime_proxy::Proxy::new(
        std::env::var("OPENAI_API_KEY").expect("OPENAI_API_TOKEN env var not set.")
    );

    ws.on_upgrade(|socket| proxy.handle(socket))
}

OpenAI recently released a new Realtime API, which lets you build conversational interfaces with almost real-time voice responses.

Their API connects directly to the client using WebSockets, which means you'll leak not only your system prompt but also your API keys unless you use some sort of proxy backend for the connection.

To solve this, I built the proxy code as a library, making it super easy to add your own logic on top and safely push the new APIs to prod!

View on GitHub

Polishing up this site

Sun, 16 Jun 2024 03:35:10 GMT

Last week, I updated some of the animations on the site and, while making sure everything looked great, noticed things were running concerningly slow.

To make things smoother, I migrated the site from Next.js to Astro, which let me strip most of the JS in the site (with little "islands" of interactivity). It now loads much faster!

A better way to organize AI prompts in Rust

Mon, 29 Apr 2024 09:49:02 GMT

use prompt_organizer::prompt;

prompt!{my_custom_prompt, r#"
    You are {name}, {user}'s AI assistant. When responding to a message,
    you add "quotes" around the message and sign it with your name.

    Make sure that the message is correctly formatted, and that the
    user's name is always capitalized.
"#}
// ^ expands to:
// pub fn my_custom_prompt(name: &str, user: &str) -> String {
//   // returns the prompt with the variables replaced, and the indentation normalized
// }

I've now built a few AI-powered Rust apps, and something that's always bothered me is that there's no good place to represent your prompts in your code. Storing them as separate files makes it harder to insert dynamic data, but keeping them inline leads to a lot of messy boilerplate.

To fix this, I built a simple macro that lets you define your prompts alongside your code, but still get nice indentation, variable replacement, and compile-time type checking.

View on GitHub

An app to easily find liked tweets

Thu, 18 Apr 2024 16:31:24 GMT

After the thousandth time going "let me find that tweet real quick" just to never find it, I decided to do something about it. Perch lets you filter all your liked tweets by author, keyword, links, the kind of media they contain and more, so you can always go back to anything you've seen.

Download on the App Store

Reverse-engineering my 3D printer's API

Wed, 10 Apr 2024 20:52:43 GMT

use bambulab_cloud::cloud::{Client, Region};

let client = Client::login(Region::Europe, "email@example.com", "password").await?;
let tasks = client.get_tasks().await?;

dbg!(tasks);
// [src/main.rs:6] tasks = [
//   Task {
//      id: 67318297,
//      length: 2783,
//      weight: 81.66,
//      cost_time: 6541s,
//      cover: Url { ... },
//      end_time: 2024-04-06T01:51:58Z,
//      start_time: 2024-04-05T23:56:48Z,
//      design_title: "Cursed Benchys #1",
//      title: "0.24mm layer, 3 walls, 30% infill",
//      ...
//   },
// ]

I recently got a Bambu Lab 3D printer, which of course means I'm constantly checking their app to see the progress of my prints. To make obsessing a little easier, I decided to reverse-engineer the API they use to fetch things like the status or preview images, and build a Rust client for it.

View on GitHub

Bringing a calmer feed to life

Sat, 02 Mar 2024 14:50:42 GMT

Scrolling through Twitter, I found a pretty sick text-only Twitter concept. I've been looking for excuses to practice my SwiftUI skills, so I took it as a challenge and turned it into a real app, adding a few fun things along the way like dithered images and a super smooth tab bar microinteraction.

View on GitHub

My first SwiftUI app

Thu, 01 Feb 2024 02:04:15 GMT

After years of putting it off, I finally got to learning SwiftUI. This first app is a very simple "talk with AI" interaction, inspired by a demo from OpenAI's DevDay a few months ago. It's extremely simple, but I'm super happy with how it turned out!

View on GitHub

A Rust SDK for World ID

Tue, 30 Jan 2024 17:27:05 GMT

Most of the World ID integrations so far have been on the web or mobile, since that's what we have SDKs for. For everyone else, I took a stab at building a Rust crate (which can be called from Swift, Python, etc.) that can serve as a more universal bridge to the protocol.

View on GitHub

Monitoring air quality with Rust.

Thu, 11 Jan 2024 01:19:25 GMT

let device = aranet::connect().await?;
let measurements = device.measurements().await?;

dbg!(measurements);
// [src/main.rs:6] measurements = SensorData {
//   со2: 962,
//   battery: 76,
//   humidity: 49,
//   status: GREEN,
//   pressure: 1017,
//   interval: 300s,
//   temperature: 25.75,
//   since_last_update: 127s,
// }

I've owned an Aranet4 CO₂ monitor for a while now, and while the device itself is great, it's not compatible with any smart home systems.

I wanted to get push notifications when the CO₂ levels in my room were too high, so I reverse-engineered the BLE protocol it uses and built a simple Rust library to interact with it.

View on GitHub

Exploring dependency injection in Rust.

Thu, 21 Dec 2023 14:30:00 GMT

use silhouette::facade::Container;

struct DBPool {}
struct DBConnection {}

// will always use the same pool
Container::singleton(&|_| DBPool::new())?;

// will resolve a new connection each time
Container::bind(&|container| -> DBConnection {
    let shared_pool = container.resolve::<DBPool>().unwrap();

    shared_pool.get_conn()
})?;

// somewhere else in your app...
let connection: DBConnection = Container::resolve()?;

Dependency injection is one of my favourite patterns (it's also the secret sauce behind Laravel), but Rust's type system and borrow checker make it impossible to fully implement.

Nevertheless, I wanted to see how far I could get, so I built a super simple service container that lets you register and resolve services, with support for singletons and closures. No interfaces tho 😅

View on GitHub

An elegant event listener package for Rust.

Wed, 20 Dec 2023 14:30:01 GMT

use epicenter::{Event, AsyncDispatcher};

#[derive(Debug, Event)]
struct ExampleEvent {}

// There'a also a SyncDispatcher you can use
let mut dispatcher = AsyncDispatcher::new();

// Register a callback to run when an event is dispatched
// This gets access to the event, so it can retrieve data from it!
dispatcher.listen(|event: ExampleEvent| async move {
    // ...
}).await;

// Dispatch an event to all listeners
dispatcher.dispatch(&ExampleEvent {}).await?;

When building a few of my last Rust crates, I found myself wanting to provide a simple way to let callers hook into certain events. While there are a few event dispatcher crates out there, none of them were simple and elegant enough, so I decided to build my own.

View on GitHub

A filesystem abstraction layer for Rust.

Mon, 18 Dec 2023 00:14:30 GMT

use flysystem::{Filesystem, adapters::{S3Adapter, s3}};

#[tokio::main]
async fn main() {
    // instantly swap between storage backends (like S3/Local/FTP)
    // by changing the type here 👇👇👇
    let mut cache = Filesystem::<S3Adapter>::new(s3::Config {
        region: env::var("S3_REGION").ok(),
        bucket: env::var("S3_BUCKET").unwrap(),
        endpoint: env::var("S3_ENDPOINT").unwrap(),
        access_key: env::var("S3_ACCESS_KEY").unwrap(),
        secret_key: env::var("S3_SECRET_KEY").unwrap(),
    }).await?;

    filesystem.write(Path::new("my-first-file.txt"), "Hello, world!").await?;
}

Continuing on the trend of building packages missing from the Rust ecosystem, I decided to try my hand at rewriting PHP's Flysystem library in Rust. After a few days of tinkering I had something extensible and easy to use, and with full test coverage!

View on GitHub

An expressive Rust library for interacting with a cache.

Fri, 15 Dec 2023 22:17:12 GMT

use amnesia::{Cache, drivers::RedisDriver};

#[tokio::main]
async fn main() {
    // instantly swap between cache backends (like DynamoDB/MySQL/Postgres)
    // by changing the type here 👇👇👇
    let mut cache = Cache::<RedisDriver>::new(RedisConfig {
        redis_url: "..."
    }).await?;

    // get `test-value` from the cache
    // or store it for 10 seconds if it's not there yet
    let my_value = cache.remember(
        "test-value",
        Duration::from_secs(10),
        my_value
    ).await?;

    // aaaand it's gone
    cache.forget("test-value").await?;
}

Lately, I've been trying to build a more intuitive ecosystem of webdev-related packages. I needed to store some things on Redis for an upcoming project, so I thought I'd take some time to upgrade the DX around caching in general.

View on GitHub

World ID 2.0

Wed, 13 Dec 2023 16:42:03 GMT

After many months of work, we're releasing the next generation of World ID. I got to rebuild the SDK from scratch and design a new way to connect with the World App, which has made everything more reliable and private.

We also launched a bunch of pre-built integrations, like Telegram or Minecraft (which was super fan to debug). Make sure to check out the announcement for all the details!

Read the announcement

A personal wearable AI

Wed, 04 Oct 2023 00:24:38 GMT

I recently flew to SF to help my friend Avi announce his startup to the world. He's been working on this necklace that listens in on all your conversations and has full context on everything going on in your life, which allows it to give you hyper-targeted advice and answer your questions in a way no other AI assistant can.

He's done an amazing job building the prototype, and on my last night before flying back I offered to pull an all-nighter and "upgrade" his backend with a focus on scalability. I managed to make it more than 10x faster and clean up the code quite a bit, and became the second human ever to own a Tab!

Watch Avi introduce Tab

Building the ultimate Mario game

Sun, 10 Sep 2023 08:13:46 GMT

Still on my journey to get good™ at YouTube, I've made another video! This time, it tries to explain how transformer networks work, with the excuse of using one to generate Super Mario levels.

I'm super happy with how everything turned out, and I hope you'll enjoy it!

Watch on YouTube

My Rust ML library is finally ready!

Wed, 16 Aug 2023 17:21:37 GMT

use cog_rust::Cog;
use schemars::JsonSchema;
use serde::{Serialize, Deserialize};

struct MyModel { ... }

impl Cog for MyModel {
    type Request: Deserialize + JsonSchema;
    type Response: Serialize + JsonSchema;

    /// Setup the model
    async fn setup() -> Result<Self>;

    /// Run a prediction on the model
    fn predict(&self, input: Self::Request) -> Result<Self::Response>;
}

cog_rust::start!(MyModel);

When I started working on a Rust version of Cog (Replicate's Python library to dockerize ML models) I set the goal of running Stable Diffusion on Replicate with no external code. Almost two months later, it finally works!

This is probably the most complex codebase I've ever worked on, and I still have a lot of ideas on how to make it better, but I thought hitting this milestone was a good time to mark it production-ready.

View on GitHub

The quickest way to commit your code

Mon, 14 Aug 2023 15:01:26 GMT

Commit is a simple macOS app, which you can invoke with a keyboard shortcut. It'll open a window where you can write a commit message, and then press enter to commit it.

It was inspired by this TailwindUI template, which imagines a fake app that does the same thing. I thought it was a cool idea, so I decided to build it!

Download on GitHub

Taking the pain out of running AI models locally

Tue, 18 Jul 2023 20:04:18 GMT

Local models keep getting more and more powerful, but the experience of running them still sucks. I've been working on Dyson, a self-hosted Replicate of sorts, which makes running a new model as easy as writing its name and using the auto-generated interface or API.

It's very different from what I'm used to (and has a surprisingly big amount of devops, which I didn't know anything about before), but I'm slowly making progress!

View on GitHub

Rust containers for Machine Learning

Wed, 07 Jun 2023 20:59:13 GMT

use cog_rust::Cog;
use anyhow::Result;
use schemars::JsonSchema;
use async_trait::async_trait;

struct ExampleModel {
    prefix: String,
}

#[derive(serde::Deserialize, JsonSchema)]
struct ModelRequest {
    /// Text to prefix with 'hello '
    text: String,
}

#[async_trait]
impl Cog for ExampleModel {
    type Request = ModelRequest;
    type Response = String;

    async fn setup() -> Result<Self> {
        Ok(Self {
            prefix: "hello".to_string(),
        })
    }

    fn predict(&self, input: Self::Request) -> Result<Self::Response> {
        Ok(format!("{} {}", self.prefix, input.text))
    }
}

cog_rust::start!(ExampleModel);

In the past I've used Cog (a Python library by Replicate) to very quickly build and deploy new models. As the state of non-Python models slowly advances (mostly thanks to @ggerganov), I thought a Rust version could unlock extra performance.

The library is still very much a work in progress, but it's already usable locally!

View on GitHub

web3 app starter

Wed, 31 May 2023 01:51:46 GMT

While working on a new project, I realized that everything I had built so far could be used as a template for other projects, so I decided to make it into a starter kit.

It's a Next.js app (using the new App Router and server actions) that includes Sign in with Ethereum, a basic UI and support for teams (letting you assign roles, invite people, etc.).

View on GitHub

New website!

Thu, 25 May 2023 06:16:04 GMT

I've felt like my old website didn't really represent who I am for a while now, and after months of trying to come up with a design I liked, I finally managed to find something unique enough.

I'll keep tweaking and adding stuff (especially to the timeline, there's years of stuff missing), but I wanted to get it out there before I started overthinking it again. Hope you like it!

Share your thoughts on Twitter

An API for ENS data

Sat, 20 May 2023 18:15:31 GMT

I really like the idea of ENS being "the universal profile", which you can set up once and every other app can follow.

To make this a little easier, I teamed up with my friend Luc to build a dead-simple API that returns all relevant attributes for an ENS name.

View on GitHub

My first real attempt at a YouTube video

Sun, 26 Mar 2023 16:00:43 GMT

I've been wanting to make YouTube videos for a while, but never really found the time to do it. A week ago I decided to challenge myself to finish a video in a week (or shave my head), and managed to do it!

The video shows how I gave GPT-4 control over a browser and taught it to browse the web, with a fun tone and a bunch of jokes. Go watch it!

Watch the video

A new design for the Worldcoin Docs

Tue, 14 Mar 2023 22:11:12 GMT

After launching World ID I felt like the docs needed a fresh coat of paint, so I deleted the previous repo and started again from scratch. A few hours later, the new site was live with new design, new content, and a new domain!

See the docs

ChatGPT for your docs

Mon, 06 Feb 2023 22:24:20 GMT

While visiting my friends from Hop, one of them mentioned it was crazy no one had built a tool that let you train ChatGPT on your app's documentation, so of course I decided to build it.

A few days (and lots of Rust) later, Clippy (MSFT don't sue plz) can "learn" your docs in ~5min and answer questions about them.

Baby's first Transformer model

Thu, 19 Jan 2023 03:24:03 GMT

Built my first Transformer model (trained on Shakespeare's works) following Andrej Karpathy's newest video lecture. It's 2:30h packed with deep knowledge, and while I definitely didn't understand everything, I learned a lot and getting the model working felt like magic ✨

Watch the lecture

An iOS widget for Worldcoin

Wed, 18 Jan 2023 03:00:07 GMT

Built an iOS widget with Scriptable, showing real-time Worldcoin onboarding stats! Uses internal APIs, so unfortunately can't share the code, but hopefully we have some public endpoints soon? 👀

Copilot, but for your terminal

Wed, 14 Dec 2022 13:25:16 GMT

After failing to remember the command to check the size of a directory for the 100th time (and looking for yet another excuse to build something in Rust), I took on building a simple CLI that could bring the Copilot experience to the terminal. Works great for things like ffmpeg!

Try it out

Adding live output to my ChatGPT Telegram bot

Tue, 06 Dec 2022 20:28:44 GMT

One of the things that's made ChatGPT really magical is its ability to show you what it's thinking in real time. While I had originally skipped on this while building my Telegram bot (since Telegram doesn't support live updates), I ended up finding a hacky way to make it work!

Try it out

A Telegram bot for ChatGPT

Sun, 04 Dec 2022 04:09:27 GMT

I got tired of opening the ChatGPT website every single time I needed to ask something, so I reverse-engineered the API and built a Telegram bot that lets you chat with it directly from the app!

Try it out

A better ChatGPT interface

Fri, 02 Dec 2022 20:39:19 GMT

ChatGPT might be one of the most impressive things I've seen in a while, but its interface is a bit lacking. I decided to try my hand at building a better one, and ended up with possibly one of the most polished things I've ever made.

Deploying Stable Diffusion models to Replicate

Thu, 24 Nov 2022 03:00:23 GMT

I've been playing a lot with fine-tuned Stable Diffusion models recently and deploying them to Replicate for blazing-fast inference, so I made a quick tutorial showing you how to easily deploy any SD model (no ML knowledge required).

Watch on YouTube

Using GPT-3 to write commit messages

Mon, 31 Oct 2022 17:00:14 GMT

After someone at work told me off for naming all my commits "wip", I decided to build a tool that automatically writes the commit messages for you.

Try it out

Script-writing app progress update

Sat, 22 Oct 2022 07:51:47 GMT

I've continued to work on Scripty, my lil script-writing app (hoping to release it soon), here's a few design details from the prototype.

Feels really crazy how fast I can go from "i wish this existed" to a prototype, coding really is a magical skill ✨

Get on the waitlist

Concept for a script-writing app

Mon, 17 Oct 2022 08:43:35 GMT

I've been writing some scripts for videos I wanna record recently, which usually has me thinking about both the script and editing details at the same time.

I tried to find something that would let me annotate both of these things at the same time, but couldn't find anything, so I made a concept for an app that allows you to define both the script and the scenes in the same place.

Get on the waitlist

Explaining web3 to a non-crypto friend

Sun, 09 Oct 2022 15:49:06 GMT

I had to improvise an explanation for what "web3" means for a non-crypto friend recently, and thought it might make a useful resource for others too, so I turned it into a lil video.

New World ID docs

Fri, 30 Sep 2022 13:46:49 GMT

When we started working on World ID, we used Gitbook for the docs. With a little more time in our hands, we decided to move to a fully-custom docs site, and it turned out pretty nice!

Check them out!

Image support for Lens Reflect

Thu, 29 Sep 2022 15:09:26 GMT

Finally managed to add image support to Reflect! After you enable the images option from your dashboard, your Lens posts will keep their images when cross-posted to Twitter.

Try it out!

A simple API for Whisper

Mon, 26 Sep 2022 17:51:19 GMT

// Reference: https://replicate.com/m1guelpf/whisper-subtitles

fetch('https://api.replicate.com/v1/predictions', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        Authorization: `Token ${process.env.REPLICATE_API_TOKEN}`,
    },
    body: JSON.stringify({
        version: '7f686e243a96c7f6f0f481bcef24d688a1369ed3983cea348d1f43b879615766',
        input: { audio_path: 'https://path/to/audio.mp3', format: 'srt' },
    }),
})

Need an API to quickly transcribe some audio? I just pushed a version of OpenAI's Whisper specialized in generating subtitles (both SRT and VTT) to Replicate, which lets you transcribe audio in the cloud with no markup from the compute cost!

Try it out!

Dynamic location for my website

Wed, 07 Sep 2022 10:00:13 GMT

As part of my quest to make my website more personal, I added a map showing where I am. It dynamically updates the location every day when I wake up, generates an Apple Maps screenshot, and a low-res placeholder.

Here's how I built it

"Now Playing" tile for my website

Tue, 06 Sep 2022 02:38:02 GMT

I've been trying to make my website feel a bit more personal, and I thought a peek into my music would be a fun start, so I built a real-time Spotify tile that shows what I'm listening to at the moment.

Prototype for ⌘K authentication

Sun, 17 Jul 2022 21:56:35 GMT

Still from a project I never got to release, which used a ⌘K menu for wallet management.

Gave a TEDx talk

Sat, 18 Jun 2022 16:52:51 GMT

Gave a TEDx talk about ConstitutionDAO, and how it was a great example of how the internet can be used to coordinate people at scale.

Watch the talk (in Spanish)

Lenster for iOS

Fri, 27 May 2022 02:25:28 GMT

I've been using Lenster a lot, and was getting tired of using Safari all the time, so I wrapped it into its own little app.

Join the Testflight

Cleaning up my Twitter timeline

Sun, 15 May 2022 06:30:14 GMT

My timeline has been a bit of a mess lately, so I built a tool to improve it. It helps you go through every user you follow, view their most recent tweets and some useful stats (like % of RTs, tweets/day, time since last activity, etc.), then choose to unfollow or hide their retweets from your feed.

Recording a TV documentary

Sun, 13 Mar 2022 14:16:55 GMT

I've been helping out with a TV documentary about the future of tech for the biggest news channel in Spain. Today was recording day!

Running an Ethereum archive at home

Sat, 12 Mar 2022 16:55:28 GMT

Finally managed to get an Ethereum archive node running at home, and point all my wallets & apps to it. Self-sovereignty feels great, and RPC calls are much faster too!

Making web apps in Solidity

Sat, 01 Jan 2022 21:18:18 GMT

Have you ever wanted to build a web app in Solidity? Me neither, but I built a barely-working server for it anyways.

View on GitHub

Animated fractal experiments

Wed, 24 Nov 2021 04:05:21 GMT

Played around with some fractal simulations now that I finally have a M1. Above is a Mandelbulb, a 3D version of the Mandelbrot set

View the source

Necromint contract

Fri, 08 Oct 2021 16:23:39 GMT

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "solmate/tokens/ERC721.sol";

struct Ghost {
    address contractAddress;
    uint256 tokenId;
}

contract Necromint is ERC721 {
    uint256 private _tokenIds;

    mapping(uint256 => Ghost) internal _ghostMap;
    mapping(bytes32 => bool) internal _uniqueMap;

    constructor() ERC721("Necromint", "DEAD") {}

    function resurrect(ERC721 spirit, uint256 soul) external returns (uint256) {
        uint256 tokenId = _tokenIds++;
        Ghost storage ghost = _ghostMap[tokenId];

        require(tokenId < 6669, "max supply");
        require(!_uniqueMap[keccak256(abi.encodePacked(spirit, soul))], "already resurrected");
        require(spirit.ownerOf(soul) == address(0x000000000000000000000000000000000000dEaD), "token not in cementery (yet?)");

        ghost.tokenId = soul;
        ghost.contractAddress = address(spirit);
        _uniqueMap[keccak256(abi.encodePacked(spirit, soul))] = true;

        _mint(msg.sender, tokenId);

        return tokenId;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_ownerOf(tokenId) != address(0), "token does not exist");
        Ghost memory ghost = _ghostMap[tokenId];

        return ERC721(ghost.contractAddress).tokenURI(ghost.tokenId);
    }
}

Built an ERC721 contract that allows you to resurrect burned NFTs, inspired by Dom Hofmann

View on Etherscan

Roam Research iOS app

Sun, 08 Aug 2021 03:21:38 GMT

Got tired of waiting for a Roam Research app so I built my own! It comes with a native "Share to Roam" extension so you can finally send notes to Roam from the native iOS menu.

Join the TestFlight

DM Newsletters on Twitter

Tue, 09 Mar 2021 16:41:21 GMT

While playing around with the Twitter API, I discovered a hacky way to bring newsletters into the platform using a DM feature meant for business chats.

View on Twitter

Spoke at Laravel Worldwide Meetup

Tue, 23 Mar 2021 20:31:09 GMT

Gave a talk about different methods of authentication for Laravel at the Laravel Worldwide Meetup. Was a lot of fun!

Watch on YouTube

3D experiments

Fri, 19 Feb 2021 12:39:17 GMT

Played around with physics-based animations in Blender. Not super fancy-looking but hey, physics!

Sign in with Apple on the web

Wed, 27 Jan 2021 03:00:00 GMT

Built a Laravel package to easily add Sign in with Apple to your app.

View on GitHub

A WebAuthn Laravel package

Fri, 22 Jan 2021 16:54:42 GMT

Built a simple Laravel package that makes integrating WebAuthn into your app a breeze.

View on GitHub

Landing page design

Sun, 07 Jun 2020 00:11:59 GMT

A landing I designed for a product that never ended up getting announced. I designed this in Sketch, taking inspiration from the old Tuple and Level landing pages, and then built it with Tailwind CSS.

A new book-reading experience

Wed, 20 May 2020 11:41:47 GMT

To celebrate a few months with my girlfriend, I bought her an eBook. However, she doesn't have an eReader, so I built a simple web app to read it on following the stories format.

See the process

Shortcut macOS app

Sun, 15 Mar 2020 13:03:38 GMT

I wanted a desktop app for Shortcut (previously Clubhouse), but they aren't planning to release one soon, so I made it myself.

Neumorphic Sitesauce prototype

Tue, 18 Feb 2020 00:13:32 GMT

Over the last few days, I scratched the whole Sitesauce codebase (while keeping a copy on git obviously) and started over, focusing on the best UI & UX I could provide.

View full redesign

Reverse-engineering Byte

Sat, 25 Jan 2020 18:48:46 GMT

Spent some time reverse-engineering the Byte API, and managed to upload a video from outside the app!

Sitesauce UI refresh

Sun, 10 Nov 2019 17:57:26 GMT

I took some time this weekend to rebuild the entire Sitesauce UI from scratch (for like 3rd time!). Happy with this iteration so far.

Skeuomorphic credit card input

Thu, 24 Oct 2019 21:20:11 GMT

A very unique credit card input for Sitesauce (using Stripe Elements behind the scenes). Didn't end up making it onto the final product, but I still love it.

Secret project prototype

Fri, 06 Sep 2019 16:22:25 GMT

Secret project video update: Been working on polishing UX & onboarding experience. Hoping to announce it very soon!

My first ever (un)conference talk!

Sun, 01 Sep 2019 21:46:35 GMT

I gave my first talk ever at the LaraconEU Unconference, and it was a great experience. Maybe I'll be on the main stage next year?

Custom backgrounds

Wed, 17 Jul 2019 15:47:01 GMT

Designed some new backgrounds for my devices, showing all the logos from past projects and my branding ✨

A Chrome extension to focus on your email

Wed, 17 Jul 2019 11:13:40 GMT

Inspired by Christian Genco, I buily a simple Chrome extension that strikes out the text of every single email except for the first one, forcing you to actually focus instead of just skimming through them.

Install extension

A theme uploader for Ghost

Fri, 28 Jun 2019 12:41:25 GMT

A Ghost theme marketplace prototype that could directly upload and update Ghost themes using undocumented API endpoints. Built in under two hours while streaming!

Launchpad OBS controls

Wed, 26 Jun 2019 10:54:10 GMT

Managed to get a really cool scene switching setup with my launchpad, using MIDI to control OBS Studio. I can now switch scenes and toggle sources with the push of a button!

Blog redesign prototype

Sat, 22 Jun 2019 14:09:52 GMT

An early version of my website's redesign which I ended up discarding.

Things web logger

Thu, 13 Jun 2019 13:30:22 GMT

I LOVE Things, but it's only available for iOS devices and I wanted to add tasks from my school Chromebook, so I made a little PWA that lets you add tasks from any device.

View on GitHub

Blogcast onboarding prototype

Mon, 22 Apr 2019 22:44:21 GMT

Built a nice onboarding for Blogcast, which explains the service and guides you while adding your first article, importing and enabling sync.

Snaptier designs

Sun, 31 Mar 2019 22:44:21 GMT

Snaptier was an automation project I worked on with some friends. We ended up shutting it down after a few months, but the designs were pretty cool.

Turn your blog into a podcast

Thu, 21 Mar 2019 07:00:16 GMT

Blogcast uses advanced text-to-speech technology to turn your blog into a podcast. I set myself the goal of going from idea to first paying customer in less than a week, and I'm happy to say I did it!

View on Product Hunt

Website redesign

Wed, 23 Jan 2019 00:02:59 GMT

Redesigned my website yet again, this time with a much cleaner look and cards for the articles. Also, dark mode!

Blogcast UI

Fri, 18 Jan 2019 17:55:53 GMT

Finally finished working on the UI flow for my new article-to-audio product! Still things to tweak, but here's an early preview.

A better Patreon for makers

Mon, 24 Dec 2018 00:30:23 GMT

Built a landing page for a product that never ended up launching. It was supposed to be a better Patreon for makers, with better integrations and an actually usable API.

An extension to toggle CSS from a website

Fri, 07 Dec 2018 08:17:34 GMT

I challenged myself to build something in an hour, and the result was a very simple Chrome extension that let you disable CSS on a website. It's now available on the Chrome Web Store!

Install extension

Personal Dashboard

Thu, 29 Nov 2018 22:00:28 GMT

A dynamic dashboard showing my calendar, Twitter interactions, current music, and more. Built with Laravel and Vue.js.

Video Embeds for Statamic

Wed, 18 Jul 2018 19:11:54 GMT

My second Statamic addon, which lets you embed videos from YouTube, Vimeo, and Wistia. It also supports custom embeds, and is fully configurable.

Beautiful docs for everyone

Tue, 19 Jun 2018 09:05:08 GMT

Since last summer, I've been working in my first real product. It aims to help everyone create beautiful documentation for their projects. Try it out!

Contributed to the Laravel framework

Mon, 17 Jul 2017 16:07:53 GMT

{{-- Tired of doing this? --}}

@if (Auth::check())
    @include('super-secret-stuff')
@else
    @include('nothing-to-see-here')
@endif

{{-- Maybe it's even worse... --}}

@if (Auth::guard('api')->check())
    @include('super-secret-stuff')
@endif

{{-- Now you can simply --}}

@auth
    @include('super-secret-stuff')
@endauth

@auth('api')
    Yay, Auth Guards!
@endauth

Added an @auth Blade directive, so you can easily check if a user is logged in or not.

View on GitHub

Learning Laravel

Fri, 13 Jan 2017 21:01:44 GMT

After a few weeks of "Inspect Element"-ing through websites, tweaking HTML/CSS, and trying to understand how things work, I figured it was time to learn a proper programming language.

The obvious next step was PHP, and after going through some courses and the PHP docs, I figured the best way to learn was by building something.

I've been working on an app for joining GitHub organizations, more on that soon!

First OrgManager commit

My first 3DS homebrew

Tue, 03 Jan 2017 21:01:44 GMT

Finally managed to get DevKitPro working, and write my first 3DS homebrew!

ConstitutionDAO

Sat, 13 Nov 2021 04:43:01 GMT

[ConstitutionDAO (📜, 📜) (@ConstitutionDAO) on Twitter: We didn't get the Constitution, but we made history nonetheless.

We broke records for the largest crowdfund for a physical object and most money crowdfunded in 72h, which will of course be refunded to everyone who participated.

To all our 17,437 contributors, THANK YOU ❤️](https://twitter.com/ConstitutionDAO/status/1461527514485035009)

Last month, my friends and I embarked on the crazy journey of trying to buy a copy of United States' Consitution. We built the DAO in less than a week and raised $42M in 4 days. Didn't end up winning, but it was a hell of a ride.

Laracon Online talk

Wed, 17 Mar 2021 19:33:44 GMT

Laracon Online (@LaraconOnline) on Twitter: Next up @m1guelpf is going to talk about the Foundation we all build upon in @laravelphp. https://t.co/Fwjy7Kw9sS

Gave a talk about the internals of the Laravel Framework to thousands of developers all over the world.

Watch on YouTube

Meta tweet

Sat, 05 Mar 2022 02:18:49 GMT

Miguel Piedrafita ✨ (@m1guelpf) on Twitter: https://t.co/BUjkIncxfG

A tweet that shows its own likes, retweets and replies (best viewed on Twitter). It generates dynamic open graph images using a headless browser, then refreshes Twitter's cache using a reverse-engineered API.

Spotify OBS widget

Thu, 29 Apr 2021 00:01:32 GMT

A super simple, real-time "now playing" widget to display your current Spotify song on stream. Was a fun little project to learn about the Spotify API.

Announcing Sitesauce

Sun, 13 Oct 2019 15:31:23 GMT

[Miguel Piedrafita ✨ (@m1guelpf) on Twitter: 🎉 I'm incredibly excited to finally unveil what I've been working on for the past month.

Sitesauce generates static sites from ANY dynamically-generated site and keeps them updated.

Learn more and sign up for early access 👇

https://t.co/34a8oLKjop](https://twitter.com/m1guelpf/status/1183404875465592832)

Sitesauce generates static sites from ANY dynamically-generated site and keeps them updated. I've been working on it for over a month now, and I'm super excited to see where it goes!

World is now live in the US

Thu, 01 May 2025 07:31:04 GMT

Ethereum (@ethereum) on Twitter: Ethereum is for humans.

After many months of work, World launches in the US! See the tweet above for some highlights of what we launched, included some things I built! 😁

ENS Delegate Checker

Sun, 06 Feb 2022 06:08:45 GMT

Built a simple website where you can see who you're currently delegating your $ENS to. Built in response to a controversy one of the top delegates was involved in.

Wallet to Twitter

Wed, 23 Feb 2022 21:53:34 GMT

Built a small website on the plane back from ETHDenver that shows you if your wallet can be traced back to any Twitter accounts, using multiple publicly-available data sources.

A Stable Diffusion Twitter bot

Tue, 13 Sep 2022 00:44:05 GMT

[Miguel Piedrafita ✨ (@m1guelpf) on Twitter: ✨ Stable Diffusion is amazing, but unfortunately it isn't trivial to setup (especially for people without good GPUs).

Instead, I made a Twitter bot that turns any reply to this tweet into an image, using SD!

Let's see what you can come up with! 👇](https://twitter.com/m1guelpf/status/1569487042345861121)

Stable Diffusion is amazing, but unfortunately it isn't trivial to setup (especially for people without good GPUs). To share it with everyone, I made a Twitter bot that turns any tweet reply into an image, using SD.

Hacker News for Lens

Thu, 26 May 2022 04:52:25 GMT

I love Hacker News because of all the amazing articles & repos I've found there over the years. To carry that sentiment into web3, I built a Lens-powered link board.

Copilot, but worse

Fri, 04 Nov 2022 03:02:25 GMT

Dumb 3AM idea: A JS package containing every function in existence. It uses Codex to generate the function's code on the fly, and then runs it.

Writing a Docker image runner from scratch 🦀

Sat, 24 Dec 2022 16:08:47 GMT

As I continue to learn Rust (and slowly run out of ideas for things to rebuild) I decided to learn more about container runtimes and build a simple one from scratch. It can run any Docker image, and it was a lot of fun to build!

A simple job queue for Rust

Mon, 16 Jan 2023 14:00:16 GMT

I had my friend Luc over last weekend, and he walked me through basic Redis commands & how to build queues with them. To practice, I built a simple job queue in Rust, using Redis as the backend. It's definitely not production-ready, but it made for a fun exercise!

Automatically overlay subtitles into any video

Wed, 28 Sep 2022 01:12:22 GMT

Built another Whisper-powered utility, which lets you automatically generate and overlay subtitles into any video. Feels insane we used to have to pay for this, and now it's just one command away.

Exploring server-side Swift

Thu, 28 Mar 2024 16:39:48 GMT

I've been having a lot of fun with Swift recently, so when I discovered there's a Swift Laravel-like web framework, I had to give it a try.

I decided to rebuild the end-to-end encrypted bridge that Worldcoin uses to connect to the World App, and was surprised to find it took 70% less code for pretty much the same app, and with a much better DX! Will definitely be using it in the future.

Standard Webhooks for Swift

Fri, 11 Jul 2025 20:07:11 GMT

I recently learned about the Standard Webhooks spec, a set of standards for properly verifying and parsing webhooks.

There are official SDKs for a bunch of languages, but not Swift, and I needed to validate OpenAI's webhooks (which follow the standard) on a Swift server, so I ended up building a package that handles both signing and verifying.

Deploying Laravel apps from GitHub Actions

Tue, 23 Jul 2024 21:53:23 GMT

I've been slowly coming back to the Laravel world, and wanted an easy way to deploy open-source apps to my server from GitHub Actions.

SSH'ing in didn't feel like the safest, so I built the system where the server is in control of the entire flow, while the still gets real-time logs streamed in. Self-hosted zero-downtime deployments for all!

lil web3

Thu, 06 Jan 2022 14:21:02 GMT

I rebuilt the most popular web3 protocols and apps in a hyper-simplified (and fully tested) repo, as a learning resource. Includes ENS, OpenSea, Fractional, Juicebox, Flashloans, Gnosis Safe, and more!

Axum Middleware for Signed URLs

Thu, 09 Feb 2023 04:12:29 GMT

After experimenting with Rust backends recently, I decided to rebuild one of my favourite features from the Laravel framework: Signed URLs.

Building a web framework from scratch 🦀

Wed, 28 Dec 2022 09:52:29 GMT

I've been learning Rust recently, and built a zero-dep HTTP server to practice (establishing TCP connections, manually parsing HTTP payloads and crafting responses, etc.). After that was finished, I kept going for a bit and built a router and some helpers to the point where it was more of a lil framework.

Wouldn't recommend using it in prod, but I'm super happy with how the DX turned out.

Named routes for server-side Swift

Fri, 24 May 2024 14:07:05 GMT

Continuing my exploration of server-side Swift, I've built a small library that lets you name your Vapor routes, providing a nicer way to generate URLs. I also managed to make it compatible with a JS library, so you can generate URLs on your frontend as well!

Massively simplifying AWS Nitro Enclaves

Fri, 25 Apr 2025 18:29:02 GMT

We've been exploring TEEs at work recently, and while it's really cool you can run any Rust code in them, the experience is full of rough edges.

After figuring out the best way to do a bunch of essential things, I decided to compile them all into an open-source crate that others can take advantage of.

Onchain human verification for Lens

Wed, 18 May 2022 20:15:13 GMT

Lens Protocol imagines a new era of decentralized social networks. To solve the issue of verification, they could use World ID and have verification be a simple on-chain transaction. Of course, I built the smart contracts to make this possible.

Taking back my feed

Thu, 01 Sep 2022 16:06:32 GMT

I recently noticed my feed had been surfacing way too many threadooors, so I built a one-click mute button for all these people recycling the same templates to get engagement.

A deep-dive into the Orb's source

Fri, 22 Mar 2024 13:06:57 GMT

Worldcoin recently open-sourced the Rust codebase that powers the Orb. To make contributing and browsing through the code easier, I sat down with some of the core contributors for an "improvised interview" of sorts, where they walked me through the overall structure.

Read the announcement

Breaking on-chain captchas

Thu, 19 May 2022 03:54:30 GMT

Came across Algoz on my timeline today, and upon looking deeper into it something caught my attention. I tried running their captchas through OCR and, after a bunch of image pre-processing, built a solver.

A mature content filter using Stable Diffusion

Tue, 17 Jan 2023 05:00:07 GMT

The Stable Diffusion safety filter has always been a mystery to me. It's not documented anywhere, and overall pretty accurate. I recently came across a paper by a group of researchers that had the same questions I did. They managed to reverse-engineer not only the logic but also the types of content the filter tries to match. Turns out, it's much simpler than expected!

Stable Diffusion already has a way of figuring out which concepts an image is closest to (this is a core part of generating images), using OpenAI's CLIP model. So you can use it to measure how close the generated image is to a list of "sensitive" concepts.

I modified the example code proposed in the paper (repo below), and deployed it to Replicate. The result: an API that can check images for adult content in less than half a second, for ~$0.00022/image.

View the code

Soulbound NFT creator

Thu, 12 May 2022 17:33:01 GMT

Souldbound NFTs have been gaining more and more popularity lately. So I built a site where anyone can create one with just a few clicks, on mainnet, Polygon and Optimism!

Hotlinking for Decentralized Social

Tue, 31 May 2022 21:28:36 GMT

Lens Protocol is one of the first decentralized social networks, meaning there's not a single place to link users to. I built a little tool that lets users chose their preferred Lens frontend, and redirects all links to it.

A WalletConnect iOS Bridge

Thu, 12 Aug 2021 12:24:03 GMT

https://app.airport.community/app/recK081nDp6EcxKJr

Made a little iOS/iPadOS app that lets you use WalletConnect on sites where only MetaMask is supported.

Join the TestFlight

A new social network

Wed, 24 Jun 2020 15:36:49 GMT

Auralite is a new social network built for people. It's mindful of your attention and your privacy. It's gonna be great.

A leaderboard for Lens

Mon, 23 May 2022 17:19:18 GMT

With every new social network, it's always interesting to keep track of the most active users and see how engagement evolves. Fortunately, Lens Protocol makes this super easy, since all the data is on-chain and indexed. So I built a little tool to look over the metrics.

Embeds for Lens Protocol

Sun, 29 May 2022 02:25:30 GMT

One of the coolest things about Lens Protocol is that you truly own your data, and can bring it anywhere you go. To help with this, I built a quick embed component for posts, comments & mirrors.

A digital pet on the blockchain

Sat, 11 Sep 2021 06:14:09 GMT

🚀 Inspired by Dom Hofmann's WAGMIGOTCHI experiment, I built a $PET NFT for you to adopt and take care of. This was my first (serious) Solidity project, and also managed to make a pretty sick fully gassless interface. Almost doesn't feel like web3!

Launching Sitesauce

Fri, 01 May 2020 09:04:39 GMT

Generate static sites from any backend in one click, and keep them updated. I've been working on it for almost a year now, and I'm super excited to finally share it!

A super-simple URL shortener

Tue, 15 Sep 2020 01:55:50 GMT

https://microl.ink/

After my previous shortener went offline, I decided to build a very simple alternative. No tracking or stats or anything crazy, just Vercel redirects.

A lil website to show some of my favourite clothes

Sat, 03 Jan 2026 19:40:22 GMT

One of my goals for last year was to develop a better sense of personal style and wardrobe. I'm very happy with where I ended up, and after seeing miguel dot clothing was available, I couldn't help it but build a lil site to highlight some of my favourite pieces!

A simple page about me

Tue, 26 Jul 2022 02:41:56 GMT

Added a new page to my site, inspired by Jack Butcher's CCV Google Docs. Will probably update it once I have a better idea of how to define myself, super happy with how clear the format feels tho.

See the inspiration

A cute raffle website for rAAVE Bogotá

Tue, 11 Oct 2022 18:33:19 GMT

While at Devcon Bogotá, Worldcoin decided to last-minute partner with Lens Protocol to raffle some rAAVE tickets. I got tasked with building both the onchain contract and the interface for it, and it turned out pretty cute!

An infinite canvas built for brainstorming.

Wed, 12 Oct 2022 15:33:19 GMT

For a long time I wondered how you would even go about building something like Figma on the web.

To dive deeper into canvas apps, I've been working on a collaborative place to brainstorm with friends, where you can drop and organize all kinds of content and embeds, with built in collaboration. It's a big work in progress, but it works!

View on GitHub

Content-gated links for your Lens followers

Sun, 05 Jun 2022 02:17:26 GMT

Built a little app that let you share links only people who follow you on Lens Protocol can access. Makes for a very simple "pay to access" portal when coupled with Lens' superfollows feature.

Announcing World ID

Tue, 14 Mar 2023 09:41:59 GMT

Today we're launching World ID. Sybil resistance is proving to be more important than I ever thought, and this is a foolproof solution, working on and off-chain that you can integrate in minutes.

We've been working to make World ID not only the most robust on-chain option, but also incredibly easy to integrate outside of crypto. For example, "Sign in with Worldcoin" allows regular web apps to become sybil-resistance in the same effort it takes to "Sign in with Google" ⚡

That means, if you're building "regular" apps with Next.js, Laravel, or anything else, you can integrate World ID in just a few lines of code. Actually, thanks to services like Auth0, you don't need code at all! Just add Worldcoin from the dashboard and you're good to go 😁

If you haven't gotten orb'd yet (or don't want to), we're also adding a phone signal to the app, which allows you to anonymously prove you have a valid phone number and a unique device, a weaker version of sybil-resistance but still much better than nothing.

Human Colossus interview

Tue, 04 Oct 2022 14:26:06 GMT

Got interviewed by a friend for the Human Colossus project, and it turned out into a pretty nice video! We covered "learning by debugging", my builder journey, and ConstitutionDAO.

Reverse-engineering Instagram's new app

Thu, 06 Jul 2023 17:41:57 GMT

Threads (Insta's microblogging app) launched today... everywhere but Europe. After getting my hands on an emulator, I started mapping out their internal API to build a client I can actually use.

It's still a big work in progress ofc, but it can already do most of the available read-only actions. More on this soon!

A native app for Overseerr

Fri, 28 Nov 2025 14:42:04 GMT

For the last few months, I've been working on an iOS app for Overseerr, an open-source project that helps you maintain a self-hosted media server.

This has been my first "real" app to make, completely by myself, start to finish, and I'm incredibly proud of how it turned out. If you use Overseerr, give it a try!

View on the App Store

Selling access to GitHub repos

Fri, 16 Oct 2020 12:58:42 GMT

After seeing a few people sponsor-lock their repos, I thought I'd build a one-time payment version. GumHub uses Gumroad and Vercel to easily sell access to your GitHub repos.

Nouns text-to-image dataset

Sun, 25 Sep 2022 06:44:25 GMT

Built a NounsDAO text-to-image dataset as an experiment, which could be used to fine-tune Stable Diffusion. It works by generating a bunch of random nouns (using 50k at the moment) then writing automated descriptions based on their attributes.

View on HuggingFace

A simple ERC721 drop contract

Thu, 30 Dec 2021 01:19:41 GMT

Decided to take Foundry for a spin and built a small NFT drop template. It exposes a simple mint() function with constants for max supply/price, and uses Solmate for gas savings.

Universal airdrop contract

Sat, 14 May 2022 01:17:49 GMT

Small project I built during the Worldcoin retreat: a contract anyone can send tokens to, that allows humans to register a wallet and claim their share of them. Most efficient way to airdrop tokens to everyone in the world!

Worldcoin is out

Mon, 24 Jul 2023 13:25:04 GMT

After almost four years of development, Worldcoin has finally launched! I've spent the last year building World ID, a fully anonymous sybil-resistance solution powered by biometrics, and now it's time to decentralize it. Download the World App, find your nearest orb, and join the network!

Playwright for Swift

Sat, 14 Mar 2026 02:43:57 GMT

I've been working on a personal data dashboard, joining together tons of data sources to get a full picture of my life. One of the sources I wanted was my YouTube Watch Later, which you can't retrieve from the API.

I have gone to extreme lenghts in the past to avoid using Python, and this time was no different. After a week of intense rewriting, you can now use Playwright from Swift :D

Working with streaming JSON in Rust

Wed, 17 Jan 2024 12:29:22 GMT

LLMs have gotten pretty good at generating structured data recently, but unlike with text you can't use the results in real-time, since the returned JSON isn't valid until the end of the response.

To solve this, I built a fast JSON syntax validator of sorts, which keeps track of the current context (are we inside a string, object, key, etc.) and can revert back to the latest valid state or complete the JSON to make it parseable.

A Chess bot in C#

Sat, 29 Jul 2023 04:50:55 GMT

Sebastian Lague recently announced a chess coding challenge, where you're given a C# framework that manages the board, generates moves, etc. and you have to write a "brain" for a chess bot.

While I'm not particularly good at C# (and know next to nothing about building chess bots), I thought it'd be interesting to participate. Definitely not the prettiest bot in the competition, but learned a lot while building it!

Contributing to Laravel Echo

Fri, 06 Sep 2019 15:24:29 GMT

Just opened a PR to make Laravel Echo automatically get the CSRF token from the XSRF-TOKEN cookie Laravel adds by default. Should improve developer experience a lot!

A tiny vector database in Rust

Tue, 04 Jul 2023 06:44:27 GMT

After seeing my friend Will build a tiny embedding database in ~500 lines of code with python, sqlite and numpy, I thought it'd be fun to try and build something similar in Rust.

I ended up rewriting the entire thing from scratch (dropping sqlite and numpy on the process) and storing everything on memory. After some performance optimizations, it was good enough to replace Pinecone on some personal projects!

YouTube subtitle generator update

Fri, 14 Oct 2022 22:39:44 GMT

A while ago, I made a simple script that generated subtitle files from any YouTube URL (using OpenAI's Whisper model).

Since then I've added support for SRT outputs (as well as VTT), made YouTube downloads +2x faster and added line break support for nicer subtitles.

YouTube subtitles with Whisper

Thu, 22 Sep 2022 16:35:36 GMT

Yesterday, OpenAI released Whisper, a neural net for speech recognition with insane accuracy, so I made a simple script that uses it to generate (very good) YouTube subtitles for any video, in seconds.

Rebuilding the ENS contracts

Sun, 02 Jan 2022 20:23:57 GMT

As a Solidity learning exercise, I built a very basic implementation of the ENS protocol, following their EIP-137 spec (w/ Foundry and Solidity tests, ofc).

A modern Swift SDK for OpenAI's Realtime API

Thu, 03 Oct 2024 01:32:47 GMT

The newly-released Realtime API from OpenAI bring almost real-time voice capabilities, and mobile apps are some of the best use cases for this new capability.

To make building these apps as easy as possible, I'm working on a super simple SDK for iOS, which lets you build full-fledged voice chat apps in less that 60 LoC (including the UI!).

Sign in with Ethereum for Next.js v13 Template

Sun, 14 May 2023 09:51:25 GMT

Wanted to use the Next.js app router for a new app that uses Sign In With Ethereum, but ConnectKit's integration only supports API routes, so I built a lil starter kit showing how to use it with app routes.

Onchain Connect 4

Mon, 31 Jan 2022 04:29:34 GMT

I built a lil contract to play Connect 4 on the blockchain! It includes a super-optimised Game contract (moves cost ~$20 on mainnet) + an NFT that the owner can mint which generates an image of the board (also fully onchain).

A fridge for your zorbs

Mon, 03 Jan 2022 03:16:37 GMT

Saw a few people sharing their ZORA orbs with frens, only to see the orb change when transferred, so I made a fridge. It freezes your zorbs so they don't change (built with Foundry & Solmate).

A better DX for Rive data binding on iOS

Wed, 11 Jun 2025 22:21:29 GMT

While working on a new app, I had to use the Rive iOS runtime for some graphics, and didn't love the way you had to manually declare all the properties and types.

To fix this, I built an Xcode plugin that automatically parses Rive files and generates all the types. It's just a proof of concept right now, but hopefully will eventually get pulled in!

Potato website

Tue, 22 Feb 2022 20:13:28 GMT

Built a simple form website for my girlfriend's potato commissions as a Valentine's day gift. I made it in less than a day using Next.js, Tailwind CSS, Mirror's design system, Prisma, and nft.storage.

Order a potato NFT

Navigation primitives for SwiftUI

Tue, 30 Dec 2025 16:48:16 GMT

Noticed that I kept copying a set of navigation helpers I built for Pocket to any other iOS app I started, so I took some time to clean them up and extract them into a Swift package.

Web3 dApp Starter Kit

Mon, 23 May 2022 02:28:28 GMT

Finally had time to open-source the template I've been using for months to quickly ship lil apps. It includes Next.js, Tailwind CSS, Connectkit, wagmi, viem, & more!

Proof of KYC contract

Sat, 16 Oct 2021 01:14:16 GMT

I've been thinking a lot about effective methods of sybil resistance since the RBN/Meka incidents. As an experiment, I built a sybil-resistance NFT claiming prototype powered by Stripe's identity verification flow.

Building a Redis server from scratch 🦀

Fri, 16 Dec 2022 11:38:25 GMT

I've taken on learning Rust recently, and decided to build a very simple Redis server from scratch to practice.

A new approach to wallet activity

Thu, 03 Mar 2022 03:13:14 GMT

Wallet history is notoriously hard to explain to users. At best you show a bunch of swaps, but every other tx is a "contract interaction". I spent the past week working on a solution (and recreating the iOS lockscreen on web to showcase it).

Adding macOS GPU support to Point-E

Wed, 21 Dec 2022 03:21:16 GMT

OpenAI released Point-E (their first attempt at a DALL-E-but-3D model) today. When I was trying it out, noticed it ran a bit slow on my mac. I managed to add basic support for M1/M2 GPUs (instead of running it on the CPU), and it got noticeably faster!

PR'd ChatGPT support to async-openai 🦀

Wed, 01 Mar 2023 20:16:16 GMT

Opened a Pull Request adding support for the new Chat API to the async-openai Rust library (which Clippy uses), so other rust-based projects could benefit from it too!

ERC20 NFT airdrop contract

Tue, 04 Jan 2022 18:32:59 GMT

Seeding an ERC20 currency with holders of an NFT seems to be becoming more of a common trend (see $AGLD, $BSTICK, $ZURR). So I built a simple contract to issue a token for any NFT (using Foundry & Rari Capital's solmate for gas optimization magic)

Ethereum Virtual Machine in PHP

Thu, 10 Feb 2022 04:47:19 GMT

A simple implementation of the Ethereum Virtual Machine in PHP. Made as a joke at 3am, do not take seriously.

The best OpenAI DevEx in Swift

Wed, 24 Sep 2025 16:48:28 GMT

I spent most of the summer updating my OpenAI Responses Swift library to support the latest API changes and make it as developer-friendly as possible.

Some of the highlights include schema-generating macros to massively reduce function-calling boilerplate, and updating the Conversation utility to handle everything you could ever need. Try it out!

A faster CLI for Whisper 🦀

Sun, 25 Dec 2022 15:58:02 GMT

Was playing around with OpenAI's Whisper C++ bindings, and ended up with a simple CLI in Rust that mimics the original one. Turns out it's orders of magnitude faster than the Python version on my M1 🚀

Showing my Lens posts on my website

Sat, 21 May 2022 03:31:24 GMT

Built a small Lens Protocol client into my website to show my posts. Having tried to do the same with Twitter a while ago, the developer experience is incredible.

Human verification for Lens Protocol

Fri, 26 Aug 2022 18:06:07 GMT

https://human.withlens.app

Social has always has a big problem with bots & spam. Together with Lens Protocol we worked on a simple solution: Have users verify themselves as human in a completely anonymous way, using World ID. The human status is then made available to all apps via the Lens API.

A video about falling asleep

Fri, 03 Jan 2025 16:42:24 GMT

It's been way too long since I made a video, especially with it being one of my main goals right now.

I worked on this one in the last few weeks of 2024 hoping to release it before the year ended, but ended up going a little over. Still, I'm super happy with it and I think you'll love it!

My first video

Tue, 20 Sep 2022 03:25:12 GMT

- YouTube

Yesterday I promised I'd stop procrastinating on video content and make a video on something. It's super basic (me talking to a camera), the editing is somewhat annoying, and could generally be improved A LOT, but it's here, and the next one will be better.

Explaining SMPC in 12 minutes

Wed, 15 May 2024 13:48:30 GMT

Worldcoin recently announced a groundbreaking SMPC implementation, used to secure the biometric data captured by the Orb.

To accompany the announcement, I flew to Poland to get a lil maths lecture from Remco covering the basics of SMPC and turn it into a video, so everyone can get a feel for how it works.

A 1h web3 crash course, for non-technical people

Sat, 22 Jan 2022 18:28:03 GMT

A few months ago, I made a stream where I got a non-technical friend and explained everything crypto to them, from blockchains and PoS, to smart contracts, ENS & more. I finally had time to edit the 5h of stream into a consumable video.

Twitter cross-posting for Lens

Thu, 02 Jun 2022 18:38:33 GMT

https://reflect.withlens.app

With new social networks come new possibilities, but also the hassle of manually cross-posting content. To fix this, I built a simple tool that automatically tweets your Lens posts.

Contextual search for podcasts

Wed, 11 Jan 2023 19:38:32 GMT

https://podcast-search.m1guelpf.me

I've been looking into semantic search this last week, and decided to build a simple demo. It indexes the Indie Hackers podcast (which I transcribed using Whisper) and lets you search through all episodes by topic of conversation. Also had lots of fun building the UI!