This article is the English translation of the Japanese article titled ‘ブログを自作システムに移行しリニューアルしました’.
Blog Migration and Relaunch with a Custom-Built System
I have recently migrated KURO’s Thinking Notes to my own custom-built blog system, Mutsura.
Building a complete blogging platform from scratch—including the API and administration panel—was something I had wanted to do for many years. However, I had always hesitated due to the time commitment involved. The project is still far from complete, and many aspects of the design are yet to be finalized, but it has reached a stage where it is functional enough for real-world use. As a result, I decided to put it into production and start using it for this blog.
Introducing Mutsura
Mutsura consists of three major components: the API, the administration panel, and the frontend blog site.
- mutsura-api: Backend for the blog system (Rust + Axum)
- mutsura-admin: Administration SPA (React)
- mutsura-front (coming soon): Blog frontend (SvelteKit)
The name Mutsura is derived from Mutsuraboshi (六連星), an old Japanese name for the Pleiades star cluster. The name reflects my hope that multiple independent programs will work together as a unified system, just as the stars form a single constellation.
One of the system’s most notable features is its bilingual support for both Japanese and English. While publishing only Japanese content is possible, the system also allows English versions to be published simultaneously.
Managing two languages under a single article ID is surprisingly difficult in WordPress, at least through standard usage. While some headless CMS platforms offer multilingual support, I wanted a system that was highly customizable and tailored to my own workflow, so I decided to build one myself.
Some of the key features include:
- Centralized management of Japanese and English articles
- Loosely coupled backend and frontend architecture
- Support for both articles and static pages
- APIs designed with SSG compatibility in mind
- JWT and refresh token authentication
- A simple and lightweight SPA administration interface
- Categories and tags for articles
- Built-in Markdown editor for easy writing
- SSG-based frontend with only the search functionality implemented as an SPA
- Simple and responsive frontend design
- Syntax highlighting powered by Shiki
- RSS 2.0, Atom feed, and sitemap support
While this may sound like a long list, I believe I have implemented most of the core features that I personally want in a blogging platform. This is one of the greatest pleasures of building your own software: you can create exactly the system you want.
Because mutsura-api and mutsura-admin can function as a headless CMS, users can build their own frontend implementations and customize the presentation layer however they like.
The source code is available on GitHub.
Why Build Yet Another Blog System?
I originally started this blog on Google Blogger and later migrated it to my own domain. Since then, I have continued operating under that domain while moving between platforms, including WordPress and a custom Astro-based site.
I have always preferred running a blog on my own domain. If you rely on an external service for publishing, you may eventually be forced to migrate when that service shuts down. More importantly, as someone who has spent many years on the internet, I strongly believe that content belongs to the domain that hosts it.
Even when publishing on external platforms, I often felt that I was contributing more to the platform’s ecosystem than building something that truly belonged to me.
Some people may argue that building a custom blog system today is unnecessary. There are countless excellent services and tools available for publishing articles, and sharing content online has never been easier.
Even in Japan, there are many platforms where anyone can start writing immediately after creating an account:
- note
- Hatena Blog
- Zenn
- Qiita
Likewise, there are numerous well-known self-hosted blogging solutions:
- WordPress
- Hugo
- Astro
- Pelican
The list could go on forever.
Given the abundance of existing options, many people may view building a custom blog system as a waste of time. However, I have always wanted an original platform that I could fully customize and completely understand down to the smallest detail.
Recently, I had been managing my Astro-based blog through Markdown files. While that worked well initially, I eventually accumulated more than 300 Japanese articles, along with corresponding English versions. Managing such a large bilingual content library through Markdown files alone became increasingly difficult. I was also dissatisfied with the frontend search functionality.
That led me to begin building a database-driven content management system with its own backend.
Interestingly, this was not my first attempt at building a blogging backend.
Several years ago, I developed kurolog, a backend for a personal SPA blog. It generated Atom feeds and sitemaps on the server side, and despite being a single-page application, it dynamically generated Open Graph metadata for certain social media platforms. The project was written in Haskell.
I considered extending kurolog for this project, but ultimately decided to start over because I wanted to:
- Use MongoDB
- Support bilingual content management
- Build a substantial project in Rust
- Create an SSG + SPA hybrid architecture
As a result, I redesigned the system from the ground up.
Technologies Used in Mutsura
The following technologies were used in this project:
| Category | Technology |
|---|---|
| Database | MongoDB |
| Backend Language | Rust |
| Web Framework | Axum |
| Frontend Language | TypeScript |
| Admin Panel Library | React |
| Frontend Framework | SvelteKit |
| Syntax Highlighting | Shiki |
| Markdown Processing | markdown-it |
| Deployment Environment | Docker |
| Container Orchestration | Docker Compose |
Impressions After the Migration
So far, I am largely satisfied with the results.
The biggest improvement is that I no longer need to manage Japanese and English articles as separate Markdown files. Being able to write and manage content through a web-based administration interface has made publishing much more convenient.
In addition, introducing a dedicated API has enabled server-side search functionality, allowing me to move away from the frontend-only search system that I had previously found somewhat limiting.
The original vision for the project is not yet fully implemented, but I plan to continue adding features and refining the system over time.
Final Thoughts
After gradually working on this project whenever I could find spare time, I am finally able to migrate this blog to the new system.
AI-assisted coding has become a major topic recently, and I did consider building much of this project through AI-driven development. However, I genuinely enjoy the process of writing code myself, experimenting, making mistakes, and refining solutions through trial and error. I still want to be actively involved in programming rather than simply directing an AI to generate everything.
For that reason, while AI-assisted coding was used in a limited capacity, the majority of the system was written by hand.
I believe there is something deeply satisfying about developing, maintaining, and improving the tools that you personally use every day.
Thank you for continuing to read KURO’s Thinking Notes. I look forward to sharing more content with you in the future.