lorebaseblog

After years of writing short stories, 3D modeling characters, and designing environments, we hit a wall. The technical art debt was crushing us. We had stories, drafts, notes, storyboards, mood boards, and production schedules scattered across a dozen different applications that refused to talk to each other.

We tried the off-the-shelf tools. We tried forcing wikis to act like databases and word processors to act like production managers. The time commitment to research and configure Obsidian plugins felt like a second job, and the templating engine turned out to be little more than a glorified copy-paste, unable to perform complex merging of data. None of it worked for the scale of what we were trying to do.

So, over the past few years, we built Lorebase to solve our own in-house problems. We needed a single, local-first production pipeline to manage the chaos.

We live in a moment where spinning up a flashy demo over a weekend is easier than ever. Modern frameworks and APIs let you mock up slick interfaces that look great in a screenshot but wouldn't survive the weight of an actual production pipeline.

Having built web applications professionally since 2004, we knew exactly what kind of foundational engineering this would take. Two decades of software development teaches you the hard difference between an app that holds together for a demo and load-bearing architecture built to last.

We began conceptualizing and building Lorebase long before the current AI boom took over the industry. It wasn't conceived to ride a hype train, and it definitely wasn't built to be a thin cloud wrapper. It was forged out of sheer necessity. We needed a robust, offline-first engine that respected our digital sovereignty and could actually handle the intricate, messy reality of our own worldbuilding and game design processes.

Building something resilient requires patience and deep technical planning. Lorebase is the culmination of a career spent learning exactly how things break, and how to build them so they don't. Because of that, we have no intention of rushing to the finish line. We’re taking the time to fully polish the rough edges, ensuring that what we finally ship is genuinely ready for real work.

It was created in-house to serve the creative chaos of our own projects. But maybe you and your team will find it useful, too.

Plain text files quickly fall short when tracking intricate family trees, balancing political factions, or managing complex TTRPG stats. As your world grows, you need a system that natively structures and connects your lore.

Lorebase is a local, database-driven wiki engineered specifically for these demands. We have combined the privacy of offline worldbuilding with a flexible system of typed properties and automatic bidirectional relationships.

Here is how Lorebase shifts the paradigm:

• Custom Schemas: Start with predefined templates for Characters, Locations, and Events, or design your own templates with custom properties to suit any element of your world.
• Two-Way Relationships: Every link is smart. If you mark Character A as an ally of Character B, both entries update and link to one another automatically, keeping factions and allegiances in perfect sync.
• Infinite Nesting: Structure your atlas with folders, nested categories, and tags that scale alongside your writing, all backed by an instant full-text query index.
• Temporal Linkages: Relationships change. A character might be a rebel ally in one era and a tyrannical ruler in the next. Lorebase lets you assign date ranges to relationships, charting how connections evolve over your timeline.

We originally forged Lorebase to solve our own production headaches, and now we're opening it up for free. We believe the tools you use to build worlds should be as independent and sovereign as the imagination that fills them.

Lorebase is built to be standalone software, not a subscription trap. No accounts, no cloud dependency, and absolutely no tracking.

Standard web map libraries like Leaflet have a hard technical ceiling. Drop a gigapixel fantasy map into them with hundreds of location pins, and the browser immediately chokes. To fix this, we ripped out the traditional DOM rendering pipeline entirely and built a custom WebGL canvas engine that runs directly on the GPU. By leveraging PixiJS, our map engine behaves more like a game engine than a traditional web map, batching hundreds of marker sprites into a single GPU draw call.

Moving the entire rendering pipeline to your graphics hardware completely removes the performance ceiling. You can place thousands of pins, track character movements in real time, and zoom through massive landscapes with zero friction.

• Draw Polygonal Regions: Outline precise borders, faction territories, and provinces directly on the canvas. Because polygon rendering is handled by the GPU rather than clumsy SVG DOM elements, performance stays flawless no matter how complex the geography.
• Infinite Sub-Map Nesting: Link specific regions directly to nested sub-maps. Seamlessly zoom from a gigapixel planetary atlas straight down into a high-resolution city street or dungeon layout without switching tabs or losing visual context.
• Real-Time Tabletop Sync: Host immersive sessions directly from your machine. With local multiplayer syncing, every movement updates instantly for everyone in the session. Watch markers and player tokens animate across the map in a smooth arc.

When you’re pasting in content from other applications, details can get lost in translation. Today, we’re peeling back the curtain on a massive architectural upgrade to Lorebase: our custom Abstract Syntax Tree (AST) Parser.

It became obvious that relying on standard Regular Expressions (Regex) was a dead end for the complexity of content we demanded. Regex is notoriously brittle and struggles with nested hierarchies. To natively support complex, dynamic content - from LaTeX equations to deeply nested character sheets and narrative zones - we needed the application to structurally understand your documents.

To solve this, we moved the entire ingestion pipeline to a high-performance Rust core compiled to WASM. The Lore Compiler parses text in the way that a C compiler understands syntax. It uses a sophisticated shielding protocol that protects your data as it's being transformed, ensuring that complex artifacts like ASCII art, BBCode, and raw HTML are transported into the editor with precision.

Keyword search breaks down at production scale. If you're looking for a specific character detail but can't remember the exact phrasing you used six months ago, standard indexes leave you digging through files manually. To solve this, Lorebase implements Semantic Discovery: a local search system that indexes the underlying concepts within your notes rather than just matching text strings.

By parsing the relational context between your entries, the engine surfaces relevant notes based on intent. You can search concepts, find conceptual overlaps, and instantly bridge gaps across your entire vault.

Engine Architecture:

• Private Processing: Vector generation and index querying execute completely on your machine. Your project data remains secure and offline.
• Automated Vision Analysis: Local pipelines generate detailed descriptions for your image assets, making your visual gallery fully searchable alongside your prose.
• Zero Network Dependency: Semantic discovery functions entirely offline, keeping your workflow uncoupled from any cloud availability.

Search architecture should act as a utility, not an excuse to harvest your data.

There is a toxic trend in SaaS worldbuilding tools that we fundamentally reject: the "pay-to-hide" model. You sign up for a free tier to organize your campaign or draft a novel, and the platform makes your entire workspace public by default. If you want the basic right to keep your rough drafts and half-finished ideas private, you are forced to pay a monthly subscription.

This isn't a premium feature tier. It is a privacy ransom.

These platforms have built a business model on the assumption that your intellectual property belongs to the internet unless you pay a toll to hide it. Rough drafts are messy. Campaign notes contain spoilers for your players. Worldbuilding involves unpolished ideas that simply aren't ready for public consumption. Charging a recurring fee just to keep your own thoughts to yourself is actively hostile to the creative process.

Privacy shouldn't be a paid upgrade. It is the default state of a local file system.

Because Lorebase runs entirely on your own hardware via a local SQLite engine and mirrored plain text files, your data never leaves your machine. There is no cloud database to accidentally expose your notes, and no privacy toggle hiding behind a credit card form.

Your world belongs to you. You shouldn't have to pay rent to keep the door closed.

You have sketches, maps, concept art, and mood boards for the things in your imagination. The Infinite Gallery is designed to be the heavy-duty media spine for your project, capable of handling thousands of assets without missing a beat.

Because Lorebase is local-first, your media isn't "uploaded"; it's integrated. Every image lives within your project vault, indexed and ready for retrieval through our virtualized high-performance architecture.

Gallery Features:

• Virtualized Scrolling: Built on a recycling scroller, the gallery can render thousands of high-resolution images with near-zero memory footprint, ensuring perfectly smooth browsing at any scale.
• Relational Filtering: Your media is context-aware. Instantly filter your entire library by character, location, or custom tags to find exactly what you need for the scene you're writing.
• ExifTool-Powered Metadata: Edit descriptions and manage tags directly within the PhotoSwipe lightbox. Powered by ExifTool, these updates are written directly into the file's native metadata headers. Your data stays with the asset, meaning other applications can read and benefit from it seamlessly.
• Dynamic Thumbnails: Keep your layout lightweight. Any image asset URL can instantly generate a fast-loading thumbnail on the fly simply by appending _thumb right before the file extension.

Without structure, a wiki inevitably turns into a messy graveyard of text files. Macro Blueprints are how Lorebase enforces consistency at scale. Instead of relying on brittle copy-pasting, our templating engine lets you define the actual data structures for your world—from character alignments to custom magical affinities.

Blueprint benefits:

• Tailored Fields: Track the details that matter to you, from character motivations to the population of your cities.
• Custom Property Types: Define fields for HP, Alignment, Population, or even custom magical affinities.
• Automation: Automatically tag entries based on the blueprint used, keeping your vault organized without effort.

We got tired of constantly alt-tabbing between a map, a character sheet, and a manuscript. Lorebase uses a custom Dockview system that lets you infinitely split, stack, and tear off panes into separate floating windows. Build the exact layout you need for the task at hand, and it will be right where you left it the next time you open the app.

• Side-by-Side Clarity: Compare drafts or cross-reference your lore without ever having to switch tabs.
• Workspace Persistence: Shut down the app or restart your machine without losing your flow. Your entire tab arrangements and multi-window layouts restore automatically between runs.

Every character, event, and location is a thread in a larger tapestry. Our Global Network Graph lets you see that tapestry as it grows, helping you understand the heart of your story.

The graph is a way to see how your ideas are coming together. It helps you identify where your story is most concentrated and where there might be room for more exploration.

Insights from the Web:

• Narrative Focus: See which characters and locations are the primary hubs of your story.
• Finding Balance: Identify "lonely" entries that might benefit from more connections to the rest of your world.
• Natural Navigation: Use the graph to move through your vault, jumping between related ideas with ease.

In a standard markdown vault, renaming a core character breaks hundreds of back-links across your files. Lorebase solves this natively. Because every entity is tracked relationally under the hood, renaming or moving a file instantly and safely propagates that change across your entire workspace. No broken links, ever.

Steady Connections:

• Effortless Renaming: Change a name once, and see it updated throughout your entire vault instantly.
• Mentions & Backlinks: Easily see where your characters and locations are mentioned, helping you maintain a consistent narrative.
• Alias Support: Easily add aliases that are tracked globally, not simply lost in text.

Multiplayer shouldn't require a Silicon Valley middleman. Lorebase uses Yjs over WebSockets to handle real-time operational transformations locally. You host a session on your LAN or VPN, and your players can join instantly via browser. True zero-server, zero-latency co-editing.

Collaborative Harmony:

• Simple Joining: Let your friends join your session with a quick QR code scan. It’s designed to be easy for everyone.
• Total Privacy: Your data stays within your own network, keeping your stories and secrets safe.
• Seamless Co-Editing: Work on the same entries together in real-time without conflicts.

Word processors force a linear flow onto a completely non-linear process. You end up copying and pasting chunks of text just to see how a scene flows in a different order. The Scene Compiler fixes this. We built an infinite canvas that lets you physically arrange your narrative blocks until the pacing feels right, and then the engine automatically compiles them back into a clean, linear document.

A Visual Way to Write:

• Story Mapping: Arrange your scenes in space to see the connections and the flow of your narrative.
• Live Harmony: Your compiled document stays in sync with your source notes, ensuring consistency across your entire world.
• The Big Picture: Take a step back and see your whole story arc at a glance before you dive into the details.

When we designed Lorebase, we knew that real-time semantic indexing and massive image processing would choke a standard Node worker. That's why we built the Lore Engine: a native Rust sidecar that handles the heavy lifting.

By moving our most intensive computational tasks like ML-based vector embeddings and parallelized image tiling into a dedicated Rust core, we achieve performance that feels instantaneous even with gigabytes of data.

Engine Highlights:

• Semantic Discovery: The engine uses local BERT models to transform your notes into high-dimensional vectors, allowing you to search by "concept" and "intent" rather than just keywords.
• Multi-Core Tiling: We leverage Rayon to parallelize the tiling of gigapixel maps, utilizing every thread of your CPU to prepare massive assets in seconds.
• Native Inference: All processing stays on your machine. The engine runs its own local inference stack, ensuring your world data never touches the cloud.