Over the last few weeks, I've been building Obscura, a token launchpad for Midnight.
There's just one problem.
Obscura's entire pitch is that your position disappears. Right now, on Midnight mainnet, nothing disappears.
Here's the actual situation: tokens already exist, the base account-based standard is live, and that's what Obscura mints against. What isn't live yet is the piece that lets those tokens vanish into Midnight's UTXO model, which is the actual mechanism the privacy pitch runs on. It's defined in MIP-0004, still sitting in Draft status, already proven out on preprod, but not deployed to mainnet.
So: a vault, built before anyone finished the lock.
Because I wasn't building for today's Midnight. I was building for the Midnight that exists six months from now.
The Idea Started With a Different Problem
Over the last six months, I've spent most of my time building on Midnight.
I joined Allit Fellowship and Build Club Cohort 1. Built DeFi protocols. Shipped mn-scaffold and midnight-wallet-kit. Ran prediction markets, lending protocols, identity systems, voting systems, escrow, most of the primitives an ecosystem eventually needs.
Somewhere in there, I also wrote the Compact Book. When I started on Midnight, there wasn't a complete resource that explained Compact end-to-end easily, so I wrote one. Twenty-five chapters later, it became one of the most widely referenced learning resources. Not bragging, just context: it's the reason I've come to trust "build the thing the ecosystem hasn't gotten around to yet" as a strategy, not just an excuse.
I also founded Midnight Skills and took it everywhere I could get a screen share - Midnight's own Fireside Dev Hangout, my own Twitter livestream, and MLH's hackathon for Midnight. That alone brought roughly 250 developers into the ecosystem.
The more time I spent building, the more I noticed a pattern.
Every ecosystem eventually reaches the same inflection point. Developers stop asking "can I build here?" and start asking "what can I launch here?"
That transition changes everything. Ethereum had it. Solana had it. Base had it. Each time, a creator economy formed around tokens, and launchpads became the infrastructure layer that made experimentation cheap.
The question was never whether Midnight would need this. The question was what a launchpad looks like when the underlying chain is privacy-first instead of fully transparent.
The Traditional Launchpad Model
Most launchpads converge on the same flow: a creator launches a token, early buyers transact against a bonding curve, price rises as supply is bought up, and once the curve hits a liquidity threshold, the token "graduates" to open trading.
Pump(.)fun popularized it. Moonshot and a dozen EVM clones refined it. The mechanics are solved.
But that whole model assumes total transparency - every buy, every wallet, every position is public the instant it happens. That's the point on Solana and Ethereum. It's also the reason every bonding-curve launch turns into a sniping contest: bots watch the chain, front-run obvious buys, and the loudest wallets win before retail even sees the chart move.
Midnight doesn't replicate that. It's built to bring privacy to programmable assets. So the real design question wasn't "how do I copy pump.fun"; it was "what does a bonding curve look like when participant positions aren't broadcast to every bot watching the chain?"
Enter Obscura
The name took three tries. It started as Nox, became Veil once I realized Nox was already in use elsewhere in the ecosystem, and finally settled as Obscura; after the camera obscura, the original device that lets you observe an image without the subject knowing it's being observed. That's the actual thesis: a market you can see clearly without every other participant seeing you.
The pitch, stripped down: fair market infrastructure, a token launch and bonding-curve market where information asymmetry isn't just discouraged, it's structurally impossible, because the chain underneath doesn't leak positions the way Solana or Ethereum do.
Mechanically, the flow looks familiar; creators deploy a token, early buyers transact against an automated curve, price discovery happens on-chain, the token eventually graduates to broader liquidity. What's different is what's hidden along the way: balances and position sizes stay shielded, so the usual whale-signals-the-move-and-everyone-front-runs-it dynamic doesn't have anywhere to attach itself.
Visually, the brand follows the metaphor all the way through; near-black background, a single copper accent, IBM Plex Mono for anything functional, Cormorant Garamond for display type, and a three-ring aperture that breathes open and closed like a shutter. Small detail, but it's the kind of thing that makes a product feel designed rather than assembled.
Simple in theory. Much harder in practice.
The First Reality Check
The first real challenge wasn't launch mechanics or tokenomics. It was infrastructure that didn't exist yet.
Earlier this year I redesigned a lending protocol twice after running into Midnight's block limits. Building Obscura felt familiar. Once again, the hard problems weren't in the whiteboard design. They appeared when the design met the actual constraints of the chain.
The piece that's missing isn't the token standard itself; it's the extension to it. MIP-0004 adds four circuits; shield, toUtxo, unshield, fromUtxo, that let a token built on the existing account-based standard convert into shielded or unshielded UTXOs and back. That conversion is what makes the shielded-position story real: without it, a token can mint and transfer, but it can't disappear into Zswap the way Obscura's pitch depends on.
It's further along than "still being debated" makes it sound; there's a working reference implementation, deployed and exercised on preprod with real transactions across the full round trip, including atomic swaps between two tokens in both shielded and unshielded form. What it doesn't have yet is Draft status promoted to Active, or a mainnet deployment. So the actual decision wasn't "wait for a standard to exist or build my own", it was whether to launch the bonding-curve mechanics now on the standard that's already live, and bring in the shielding layer once MIP-0004 clears mainnet, or hold the whole product until a still-Draft extension is fully rolled out.
I chose to ship. Obscura's v1 launches on the existing account-based standard; the curve, the mechanics, the launch flow all work today. The deeper privacy guarantees that MIP-0004 unlocks; full shielded position-hiding through UTXO conversion, are the v2 layer, adopted once the extension is stable and live on mainnet rather than sitting on preprod. That's not a shortcut I'm hiding; it's the actual trade-off. Waiting on a Draft proposal to formally graduate means losing the only thing an early mover actually has: time.
That's the real lesson buried in this project, and it had nothing to do with code: a working product and a launchable product are not the same thing. Obscura works. Whether it's launchable at full strength depends on pieces outside the application entirely; token standards, liquidity rails, the parts of the ecosystem that aren't mine to control.
Why Build It Anyway
Because ecosystems don't produce infrastructure on their own. Someone has to build it first, before it's obviously needed.
I've already run this play once. The Compact Book shipped before the Foundation's own technical DevRel team finished a comparable resource. It became the canonical reference anyway, not because it was the most polished thing that could've existed, but because it existed when nothing else did.
Every mature ecosystem has a graveyard of things built too early. It also has a handful of things that became foundational because they were early. I don't know which pile Obscura ends up in. That's not really the point.
The point is that building before the rails exist teaches you things documentation can't. You find the bottlenecks nobody's written about. You find the missing standards. You find which of your assumptions don't survive contact with a chain that's still being built under you.
The Biggest Lesson
Before building Obscura, I thought launchpads were a token problem, get the contract and the curve right, and the rest follows.
After building Obscura, I think launchpads are a distribution problem. The contracts matter. The curve matters. The standard matters. None of it matters if nobody launches, and nobody launches without distribution, liquidity, builders, and a reason to show up on day one.
Technology creates the possibility. A community creates the adoption. The best launchpad in the world is just an interesting demo without an ecosystem willing to use it.
Building Ahead of the Ecosystem
"Build for where the ecosystem is going, not where it is today" is the kind of line that sounds like a poster until you're actually doing it, and then it's just a description of your Tuesday.
Obscura isn't a bet on current activity; there isn't much yet. It's a bet that Midnight's token economy shows up eventually, that creators will want launch infrastructure when it does, and that privacy-preserving assets open up mechanics that don't exist on fully transparent chains at all. Shielded position sizes aren't just a privacy feature, they remove an entire category of extractive behavior that every transparent-chain launchpad has had to design around after the fact.
Maybe the bet is right. Maybe it isn't. The only way to find out is to build it before it's obvious.
What's Next
Obscura is still an early look at what token launches on Midnight could be; not a finished product, and not pretending to be one. The waitlist is open now at obscura.sevryn.xyz, and as MIP-0004 clears Draft status and lands on mainnet, a lot of what's true about this version will change. That's expected. Building early was never about getting everything right on the first pass, it's about learning faster than everyone else gets the chance to.
Maybe Obscura launches six months too early. Maybe it becomes one of the first launchpads people use when Midnight's token economy arrives. I genuinely don't know.
What I do know is that by the time everyone starts asking how to launch a token on Midnight, I won't be asking the question anymore. I'll already know the answer.
If you want the deeper technical context on how Compact and Midnight's ZK model work under the hood, I wrote the Compact Book, it's the resource I wish existed when I started.
