TL;DR

My blog is a static Jekyll site with a bunch of integrations (Plotly, KaTeX, Mermaid, Photoswipe, Giscus, Umami). It’s evolved over two years and I think it’s genuinely useful for technical writers. The code is messy. Should I publish it? I don’t know. This post is me thinking out loud.

The Setup

I built this blog incrementally. No grand vision at the start, just a Jekyll site that I kept tweaking as I needed new features. (this post share quite a bit of the journey Yuk’s Blog: 2024-2025 Retrospective) Two years later, it works. The markdown renders. The interactive plots work. The comments work. The analytics work. All free, all via CDN or light dependencies.

If I were to describe it to someone: a straightforward static blog setup for people who write technical content and want control over their tooling. Not WordPress plugin territory. Not “just use Medium.” Something in between.

The thing is: I’ve never published the code. It lives in my GitHub, private repo. And I keep thinking about whether I should or nah.

Why I Want To

1. It’s genuinely useful

Technical writers, simulation hobbyists, people building their own corners of the internet, they’d probably find this valuable. Not many people have put together a deliberately minimal Jekyll setup with Plotly, KaTeX, and Mermaid and Photoswipe working smoothly. Most blog templates are either bloated or sterile. This one isn’t.

2. The evolution is honest

I didn’t design this from first principles. It evolved. And that’s actually the point. The way I code, the patterns, the pragmatism, the “good enough,” the two-year journey of refactoring and pivoting, all of that lives in this codebase.

Someone else building a blog doesn’t need a pristine product vision. They need to see how a real person actually built something over time. Messy code is honest code.

3. I want input from people smarter than me

This is the real one. I’m not expecting this to “blow up.” I’m hoping that someone, somewhere, sees it and thinks “oh, I can improve that” or “I use this too, here’s a better way.” The code is “usable” now, but there are definitely rough edges (really rough tbh, i got a dedicated .css and .js file for each page lmao). A community fork might actually make it better.

4. The blog’s already public anyway

The site exists. You can see it. You can see what it does. Publishing the code just makes the kitchen visible. That’s a lower-stakes decision than I keep telling myself it is.

Why I’m Hesitating

Fear #1: Nobody cares

Most open-source projects get zero attention. I release this, it sits on GitHub, no one forks it, no one contributes, and then… I’m exactly where I started, except now I’ve got a public repo labeled “slop” on my profile.

But here’s the thing: my blog is already up. I’m not launching a product. I’m opening the kitchen. Worst case, the kitchen stays closed and I move on.

Fear #2: Credit anxiety

This is the one I’m less comfortable admitting: I do care if people know I made this. Even though I say I don’t care about maintaining it, even though I claim I just want the community to help… I also want my name on it. I want to be remembered for two years of work.

Fear #3: The mess is overwhelming

Removing hardcoded stuff takes time. Documentation takes time. I’d have to think about which features to highlight vs. deprecate. And right now, honestly, I don’t want to. The blog works for me. Polishing it for public consumption feels like a full-time job.

What I Actually Want

If I’m being honest: I want to publish it as-is, messy and all. Write a good README that says “here’s what this is, here’s how it works, here’s what I’d do differently now.” Add one or two example posts so people can see the structure. Maybe a .gitignore for sensitive personal stuff.

Then… let it go. Stop maintaining it. Hope someone picks it up and makes it better.

The part that scares me isn’t the publishing. It’s the lack of control afterward. And I need to sit with whether I can actually be okay with that.

What I’m Asking

Not looking for permission. Not looking for a yes/no. I’m genuinely asking:

• If you’re a technical writer or someone who cares about their blogging setup, would you find this useful?
• Does the “messy two-year evolution” angle interest you, or does it just look unprofessional?
• If I publish it unpolished, would you fork it? Or would you skip it because it doesn’t feel “production-ready”?
• Am I overthinking this?

I have a comment section below. Hit me with your honest take.

The Actual Plan (Maybe)

My friend said something simple: “just public it.”

And maybe that’s the answer. Not because it’s perfect. Not because I’m confident it’ll help people. But because:

1. It won’t hurt to publish it.
2. The honest, messy version is more useful than the polished-but-never-released version.
3. If someone wants to improve it, they will.
4. If no one cares, I move on and keep building.

So maybe next week I do that. Remove the hardcoded stuff, write a README, push it public.

Or maybe I don’t.

Either way, writing this helped clarify what I actually want: not validation, not a decision, but the possibility that something I built with genuine care might be useful to someone else.

That’s enough.

If you made it this far: what’s your take? Comment below, I’m genuinely curious.