A blog engine looks simple from the outside: entries go in, pages and feeds come out. Inside, it is a compact publishing system where storage, rendering, identity, protocols and URLs have to keep agreeing for years. This reference explains those parts with particular attention to the .NET ecosystem and the file-based approach used by several early engines.
This site is an independent reference on .NET blogging engines. It is not affiliated with, endorsed by, or connected to the dasBlog project, DasBlog Core, or its maintainers. The dasBlog project lives at github.com/poppastring/dasblog-core.
A field guide, not a product manual
The subject is bigger than any one codebase. Early ASP.NET weblog engines explored how a small site could publish from XML files, expose RSS, accept posts from desktop software, render a theme and keep old links alive. Later systems brought database-backed content, MVC and Razor views, headless APIs, static generation and federated publishing into the same conversation.
Those changes did not erase the earlier questions. They sharpened them. Should a post be a file that can be copied or a row governed by transactions? Is the canonical record the editor database, the rendered HTML, or an export? Which part of a URL is an implementation detail, and which part is a public promise? The storage comparison and permalink guide treat these as operational decisions rather than fashions.
Read the system in layers
Content and rendering
Start with files versus databases, then move to themes and templates. The storage model determines how backups, edits and migrations behave; the rendering model determines how that content becomes a page.
Distribution and writing
RSS and Atom distribute new entries to readers, while publishing APIs let external editors create them. Both depend on clear identifiers and stable public links.
Operations and continuity
Self-hosting joins application, proxy, TLS, storage and backups. Migration is the test of whether those layers were understood.
Why the history still matters
Blog engines are unusually good architectural case studies because their useful life can exceed the life of their original framework. A post may outlast a server, theme, domain owner, database driver or deployment model. The history of .NET blogging engines follows that continuity from BlogX and classic dasBlog through later .NET publishing projects and the current DasBlog Core codebase.
dasBlog is covered here by name as one project in that history. Its current repository describes a blogging engine built with ASP.NET Core that preserves the essence of the original while using modern cross-platform .NET. Readers looking for the actual project should use the current DasBlog Core repository. This site does not provide project downloads, setup instructions, support or release guidance.
Use the reference as a review tool
Each article includes questions that can be applied to a real publication without prescribing a particular engine. Trace one entry from its canonical source through rendering, its HTML URL, feed item and any federated representation. Then trace the reverse path from a reader's old link back to the current content. Gaps between those views reveal where an upgrade or migration needs explicit mapping.
A useful review ends with a written decision: what is authoritative, which addresses are permanent, which interfaces are supported and how the publication will be restored. That small record turns general architecture into an operating agreement.
Choose a route
If you are preserving an existing site, begin with URLs, exports and backups. If you are studying protocols, begin with feeds, MetaWeblog, WebFinger and ActivityPub. If you are comparing architectures, begin with storage, templates and static output. Every route arrives at the same principle: publishing systems change, but public identifiers should remain understandable and durable.