The Episcopal Priest Building Rust's Hottest Web Framework

There's this moment in tech Twitter when someone discovers that the maintainer of their favorite tool has a completely unexpected day job. That cognitive dissonance—the "wait, WHAT?" moment—usually happens when you learn someone's building infrastructure at night while teaching kindergarten by day, or writing compilers between shifts as an EMT.

But Reverend Greg Johnston might have the most unexpected combination yet: He's an ordained Episcopal priest who created Leptos, a Rust web framework that's racked up over 19,000 GitHub stars and become a genuine contender in the "what comes after JavaScript" conversation. He's got degrees from Harvard and Yale Divinity School. And he sits in his church office debugging WebAssembly.

The weirdest part? He says it makes perfect sense.

How You End Up Here

Johnston's origin story starts exactly where you'd expect for someone who builds web frameworks: with a CIA rejection letter. "I got rejected from the CIA and so it was pretty much the only thing left," he jokes about going into ministry, though the truth is more textured. Growing up post-9/11, he developed a fascination with the Middle East, learned Arabic and Farsi, and thought maybe the national security apparatus was "a way of being involved in the world for good." The CIA disagreed—he was "a little too soft and gentle and diplomatic" for their taste.

Which, fair. Those qualities work better when you're helping people make sense of their lives through shared traditions and texts, which is how Johnston describes most of his ministerial work. "Sometimes that's the joyful parts of life and sometimes that's the sad parts of life and a lot of times it's just ordinary life."

The programming part started way earlier, at age 10, when his elementary school's mentor program paired him with someone in the field. He built a Java applet of a dog you could control with arrow keys—the kind of project that either kills your interest in coding forever or hooks you completely. For Johnston, it was the latter. He spent his teenage years deep in the weeds: writing assembly, building a mini operating system with a bootloader, creating a running log application in Scheme (a Lisp dialect, because apparently some kids just skip the normal progression and go straight to the esoteric stuff).

But here's the thing that actually matters: Johnston never asked himself "what project should I build?" He had the opposite problem—too many concrete things he wanted to make, never enough time. The programming was always in service of something else he cared about.

The Accidental Framework

Leptos exists because Johnston made what he calls "a series of mistakes." First mistake: picking up the Rust programming language book during summer vacation in 2020 because he'd heard it was "the most loved programming language seven years in a row." Second mistake: realizing Rust solved a bunch of problems he had with JavaScript, particularly around working with nested document models and pattern matching. Third mistake: deciding to rewrite some church-related tools he'd built, then discovering he didn't love any of the existing Rust web frameworks.

Fourth mistake, the big one: building his own framework and then—catastrophically—sharing it with people.

"Then people actually use it and then you get excited about that and then it turns into a whole another thing," Johnston says. That "whole other thing" is now Leptos, which he describes as analogous to React with Next.js or Vue with Nuxt, except you're writing Rust instead of JavaScript. It handles server-side rendering, runs in the browser for interactivity, does everything the JavaScript frameworks do—just in a language most web developers find intimidating.

The adoption story is fascinatingly opaque. Companies use Leptos, but they usually don't announce it. Johnston often doesn't know who's building production apps with his framework until they reach out for support or sponsorship. No big tech company is broadcasting "powered by Leptos" on their homepage. It just... works, invisibly, the way good infrastructure should.

"If I just link you a website, it's just a website," Johnston points out. "There's nothing flashing on it that's like powered by Rust, right? It functions like an ordinary web application does."

The Part Nobody Talks About

What's interesting isn't that Johnston lacks formal CS training—plenty of great developers are self-taught. It's how he thinks about the gaps in his knowledge. When he started maintaining Leptos as a real open-source project with actual users, the hard parts weren't computer science concepts. They were GitHub Actions. CI/CD pipelines. Automated testing practices. The professional infrastructure that surrounds code.

"I was horrible with Git when I first started maintaining an open source project that people were using," he admits. Meanwhile, he'd already been writing assembly as a teenager and was comfortable with stack versus heap memory—concepts that trip up developers coming from JavaScript into Rust.

His relationship with impostor syndrome is revealing: "Nobody's ever been paying me a salary to do things that I feel like I don't know." He's been sharing things as open-source software, transparent about limitations, operating in a space where "you get what you pay for" is actually a reasonable framing. There's no performance anxiety when you're not performing for a paycheck.

But also: "There are lots and lots of things that I don't know but there's nothing that I feel like I can't learn." He knows nothing about GPU programming, for example, but he's confident he could learn enough to be useful if he needed to. That confidence comes from having actually done the thing repeatedly—learned different domains, experimented, failed, figured it out.

What This Actually Means

The developer world has spent years arguing about whether you need a CS degree, whether bootcamps work, whether self-taught developers are "real" developers. Johnston's path suggests those might be the wrong questions entirely.

He didn't learn programming to become a programmer. He learned it to build things he wanted to exist. The motivation was never "master this skill" but "solve this problem." When he came back to programming as an adult, it was because he had church-related tools people actually needed, and programming was the mechanism to deliver them.

That orientation—building from necessity rather than studying for mastery—shaped what he created. Leptos exists because Johnston had a specific set of frustrations with JavaScript and a specific set of requirements for his projects. It reflects his particular path through technology: early exposure to systems programming, comfort with functional paradigms (hence the Scheme), impatience with JavaScript's data handling, and ultimately a need for something that just worked for the things he wanted to build.

The ministry and the framework maintenance aren't separate lives that happen to coexist in one person. They're both expressions of the same impulse: providing tools that help people do what they're trying to do. In one context, those tools are rituals and texts and community structures. In the other, they're reactive primitives and server functions and WebAssembly compilation. Different domains, same fundamental drive.

"It's so wonderful to have two different outlets where when things are hard over here, I can kind of lean into this," Johnston says about balancing ministry and open source. "When things are hard over here, I have the comfort of this."

Which maybe explains why Leptos keeps growing despite being maintained by someone who's also, you know, conducting Sunday services. The framework isn't competing with his vocation—it's complementing it. Both involve helping people build things that matter to them. The syntax is just different.

—Zara Chen 🦀⛪