Announcing Open Source for doi.bio’s Node.js Core Infrastructure

Introduction: Markdown-Powered Scientific Publishing

At doi.bio, our mission is to reinvent how scientists publish and share knowledge. We’ve built a platform that treats scientific content the way developers treat code — using simple Markdown files and modern workflows inspired by Obsidian’s note-taking paradigm. In short, doi.bio is a “GitHub meets DOIs” approach to publishing. Instead of relying on slow, centralized DOI registrars, we empower researchers to create and link content directly through a code-first system. Every paper, dataset, or insight can live in a Markdown document (with backlinks, embeds, and all) that’s easy to version, share, and interconnect with others. Today, we’re thrilled to announce a major step in our journey: the core Node.js server that powers doi.bio is now open source, available for everyone at our GitHub organization doi-dot-bio. This move opens the door for developers to run their own doi.bio nodes, extend the platform, and help build a decentralized ecosystem for scientific knowledge.

Open Sourcing the Node-Based Engine of doi.bio

From day one, we designed doi.bio with a transparent, modular architecture — one that developers could inspect, adapt, and trust. Now we’ve taken the next logical step by open-sourcing the central Node.js infrastructure that runs the platform. This Node.js server is the heart of doi.bio: it resolves DOI.bio identifiers, serves content, indexes Markdown files, and orchestrates advanced features behind the scenes. By releasing the source code (under an open license) at **https://github.com/doi-dot-bio*, we invite the community to peek under the hood. You can now see exactly how the system works and even improve it. We believe that an open architecture will accelerate innovation and reliability. Just as doi.bio’s registration model treats DOI creation like contributing to an open-source project, our core codebase is now a collaborative project as well. This is more than a repository launch — it’s a commitment to building doi.bio with the community of scientists and developers, not just for* them.

What’s in the Open Source Release?

• Node.js Server (server.js) – The main application that powers doi.bio. It’s a lightweight Node/Express app that serves the front-end and provides a minimal API. This server handles everything from rendering Markdown content to processing user commands
• DOI Resolver and Indexer — The logic that parses DOI.bio identifiers and Markdown files, returning rich content and metadata. The server leverages GitHub’s decentralized model (for ID namespaces and versioning), meaning it can fetch community-contributed records and integrate with our open DOI registry.
• Content Graph Builder — A module that automatically links documents via references and backlinks (inspired by Obsidian). Whenever you add or update Markdown files, the server indexes them and updates the knowledge graph, so each document “knows” its connections in the network. This ensures a hyperlinked, backlinked structure where any data point can be easily referenced and navigated.
• Plugin-Friendly Design — While still a young project, the core is built to be extensible. The open source code is modular, making it straightforward to add new features or integrate external tools (more on that below). We welcome pull requests and new ideas from the community to extend doi.bio’s capabilities.

Easy Setup: Run Your Own doi.bio Node in Minutes

One of our goals is to make the developer experience as frictionless as possible. You shouldn’t need a PhD in DevOps to spin up your own scientific publishing server. With this open source release, getting started is as simple as cloning the repo and running node server.js. Here’s how you can try it today:

1. Clone the Repository: Grab the code from our GitHub (git clone https://github.com/doi-dot-bio/<repo-name>.git) and navigate into the project directory.
2. Install Dependencies: The core server has minimal prerequisites — just install Node.js (v14+ recommended) and run npm install to fetch the needed packages. We chose Node for its cross-platform support and rich ecosystem, so this works on Windows, macOS, or Linux out of the box.
3. Run the Server: Launch the app with node server.js. By default, it will start a local web server (e.g., at **http://localhost:3000). The server immediately begins indexing the default content (or your specified Markdown folder) and serving the web interface. In essence, your personal doi.bio node is now live**. 🎉
4. Configure & Customize: You can point the server at your own collection of Markdown files (such as an existing Obsidian vault of research notes) by adjusting the config or environment variables. The goal is zero-hassle integration — if your notes are written in Markdown with standard link syntax, the doi.bio server will automatically recognize links, citations, and even embedded media. No special formatting needed.

This lightweight setup means you can run a doi.bio node on your laptop for personal use, on an internal lab server to share content with colleagues, or even deploy it to the cloud for a larger community. We’ve kept the requirements modest so that even small research groups or individual enthusiasts can host their own node. The developer experience is intentionally simple: no databases to set up, no complex build process — just Node.js doing what it does best (serving content and handling requests). And because the system stores data as flat files (Markdown, JSON, etc.), it aligns with Git workflows and is easy to back up or version control.

Publishing in Markdown, Obsidian-Style

Why Markdown? Because we believe scientific writing should be as straightforward as writing a note. With doi.bio, you author content in plain text Markdown — which means you get all the benefits of a lightweight, readable format that plays well with tools like Obsidian, VS Code, or Jupyter notebooks. Our platform was heavily inspired by Obsidian’s approach to linking notes and maintaining a knowledge graph. If you already organize your papers, ideas, and experiments in an Obsidian vault, doi.bio will feel like a natural extension of that workflow.

When you run the doi.bio server on a folder of Markdown files, it automatically:

• Parses Internal Links: Use Obsidian-style wiki links ([[Like This]]) or standard Markdown links to reference other notes. The server resolves these and turns them into navigable hyperlinks in the web interface, connecting your documents together. Backlinks are also generated – open any page to see what other notes reference it, turning isolated notes into a connected web of knowledge.
• Indexes Metadata: The server looks for YAML front matter or special sections in your Markdown (like titles, authors, keywords) to build an index of your content. This makes it possible to search by author or tag, list recent updates, or populate a content directory automatically. We aim to support basic scholarly metadata too — for instance, you can include a DOI for a reference, and the system can retrieve its citation info.
• Handles Citations and References: Managing references is a breeze. You can paste in a DOI or arXiv ID and the server will fetch the bibliographic details (via Crossref or other APIs) to display alongside your content. Likewise, reference lists can be generated or updated on the fly. Essentially, your Markdown files become self-updating mini-publications.
• Supports Obsidian Embeds and Transclusions: If you use Obsidian’s ![[note]] embed syntax or Markdown includes, our server honors those. This means you can reuse content across documents – e.g. embed a “Methods” section from one note into multiple papers – achieving true content modularity. This concept of transclusion (thanks to Ted Nelson’s Xanadu!) gives you the power to maintain one canonical version of a section and include it wherever needed. Edit the source once, and all the documents that include it will update, saving you from copy-paste chaos.

By sticking to Markdown and simple conventions, we ensure that your content is portable. You’re never locked into a proprietary format — you can take your notes elsewhere, put them on GitHub, convert to PDF/LaTeX for journal submission, or anything you need. But when served through a doi.bio node, those same plain-text files transform into a rich, interactive knowledge base.

Local Node “Superpowers”: Beyond Static Publishing

Running a local Node.js server for your content doesn’t just imitate a static site — it augments your content with dynamic capabilities that static Markdown alone can’t provide. We like to say it gives your writing superpowers. Here are a few enhanced functions now at your fingertips:

• Interactive Data Visualization: Scientific results often involve complex data — structures, graphs, sequences. The doi.bio server can embed interactive widgets directly in your Markdown pages. For example, we integrate the Mol* toolkit (Molstar) for molecular visualization. This means you can include a protein structure or chemical model in a document, and readers can rotate, zoom, and explore it live in the browser — no plugins or separate apps required. Imagine writing about a protein design and having a 3D model right beside the text. With a local Node server, such rich embeds are possible because it can serve the necessary scripts and handle the data. Similarly, you could embed plots (via libraries like Plotly or D3) or interactive genomic maps. Your Markdown is no longer just text — it’s a canvas for interactive scientific content.
• Real-Time Search and Indexing: The Node backend continuously indexes your documents, enabling fast full-text search and filtering across your entire collection. Type a query in the interface, and you get instantaneous results, even as you add new content. Because the server is running locally or on your chosen host, you can scale up the indexing power (use more CPU/RAM) for bigger libraries without relying on a third-party service. The search index updates “eventually consistently” as you modify or add files, so the link graph and references remain up-to-date with minimal delay.
• Automated Processing and Analysis: We designed the core server to play nicely with additional backend processes. Think of it as a hub that can farm out tasks to worker modules. In fact, our architecture uses a file-based message queue to coordinate with AI or data-processing microservices. In practical terms, this allows you to hook in advanced features like natural language summaries, entity recognition, or format conversions. Want every new note to run through a text-mining algorithm to tag genes and proteins? Or generate a summary for the sidebar? By adding a small worker script (Node, Python, etc.), your local server can perform these tasks and integrate the results into the content. This is the kind of superpower a local server provides — you become the master of your data workflow.
• Custom Plugins and Extensions: Because the platform is open source and Node-based, developers can extend it with plugins. We envision a library of community plugins in the future: imagine a statistical analysis plugin that auto-formats any included CSV data into summary tables, or a Jupyter notebook plugin that executes and inlines results of code blocks. Since you control the server, you could even give it access to local resources — for example, querying a local database or performing computations on a GPU — and then present the output in your Markdown content. This augmented publishing model blurs the line between writing and computing, empowering scientists to create documents that are interactive dashboards or live notebooks, not just static text.

Crucially, all these enhancements run on your machine (or server). We think this is a huge win for privacy and flexibility. You might be working with sensitive data or preliminary results that you’re not ready to put on a public website — with a local doi.bio node, you get powerful visualization and analysis tools without needing to upload your data to someone else’s cloud. It’s like having a personal, supercharged “DocuScope” that’s limited only by what you plug into it.

Towards a Decentralized, Community-Driven Ecosystem

By open-sourcing our core and enabling anyone to spin up a node, we’re taking a step towards a more decentralized model of scientific publishing. Instead of one central repository or publisher hosting everything, we envision a network of interoperable doi.bio servers — run by labs, universities, or independent researchers — each publishing their own content yet all speaking the same language. Each node can act as an independent publisher and as part of a greater federation of knowledge:

• Unique IDs, Global Discovery: Thanks to the DOI.bio identifier scheme, content published on any node can be referenced globally. If your lab runs a server at, say, lab.org/doi.bio, and you mint an identifier like labOrg/cancer-study-2025, anyone from any other node or from the main doi.bio site can resolve that ID to find your content. The use of GitHub namespaces for DOIs ensures no collisions and no central authority needed to issue prefixes. It’s built-in decentralization.
• Cross-Node Linking: Your Markdown documents can cite work from another group by using their DOI.bio IDs or even legacy DOIs. If a reference isn’t found locally, the server can fetch it from the global doi.bio index or through Crossref for traditional DOIs. This means each node benefits from the content of all others — a true network effect. We’re essentially creating a distributed knowledge graph of scientific information. Over time, as more nodes come online, the connectivity and resilience of this network will grow. There’s no single point of failure; even if our main site went down, community-run nodes can continue the mission.
• Community Governance and Contributions: A decentralized ecosystem is inherently community-driven. By releasing the source, we invite researchers and developers to contribute improvements, whether it’s new features, language translations, or better integration with existing tools. Imagine each lab building plugins suited to their discipline and sharing those so others can benefit — one group might add a chemistry diagram renderer, another an astronomy data viewer. The diversity of the community becomes a strength of the ecosystem. Just as important, decentralization empowers authors. You’re not at the mercy of a journal’s platform or a single website’s policies; you have control over how and where your work is hosted and presented. This aligns with the broader movement in tech toward decentralization (from federated social media to blockchain), but here applied to scholarly communication.

Our dream is an interoperable web of scientific writing where knowledge flows freely. Doi.bio nodes will speak via open protocols and formats, so they can interconnect with other systems too. For example, we aim for compatibility with tools like Pandoc, Zotero, or open notebook platforms — anything that fosters data exchange. Ultimately, this could dovetail with ideas of decentralized science (DeSci) and open science, by creating infrastructure that anyone can spin up and no one entity monopolizes.

Faster, More Connected Publishing with Reusable Content

Beyond the technical architecture, what does this mean for scientists day-to-day? In a nutshell: it becomes much easier (and faster) to publish and iterate on scientific content. We’re advocating for a shift from the slow, monolithic paper publishing cycle to a more continuous, component-based workflow. Here’s how doi.bio’s open infrastructure helps achieve that:

• Rapid Publishing of Micro-Papers: Since anyone can create a DOI.bio entry by contributing metadata or content to the open registry, publishing no longer requires months of waiting or navigating paywalls. With your own doi.bio node, you could release a finding as soon as it’s written and reviewed internally — for example, a short “micro-paper” documenting a new dataset or a preliminary result. Each such post is immediately citable (with a DOI) and accessible. This encourages sharing many smaller contributions rather than holding back for one big publication. Science can move faster when we publish in increments.
• Reusable Content Blocks = Less Redundancy: Traditional papers are written largely from scratch each time, often repeating background information or methods. In our system, you maintain a library of common text blocks (methods, protocol descriptions, literature reviews, etc.) as separate Markdown notes. You can then transclude or link these into new papers, as described earlier. This dramatically cuts down the time to assemble a new manuscript — you’re not re-typing standard paragraphs; you’re pulling in already-polished text that you can update if needed. The result is not cookie-cutter papers, but rather consistent, high-quality sections that evolve over time. When that protocol improves, you update one file and all future uses of it will fetch the latest version. Authors become curators of living content, and publishing becomes an exercise in selection and synthesis, not starting from a blank page every time.
• Instant Connectivity and Feedback: Because everything you publish is part of a connected graph, your new content immediately links to related existing knowledge. For instance, if you publish a new dataset and reference previous studies, those references become live links; anyone reading your dataset can seamlessly jump to the supporting papers or even to your lab notes analyzing the data. This context-rich publishing means each piece of science doesn’t live in isolation — it’s embedded in a web of context. Readers (and automated agents) can follow chains of evidence, from a figure in a paper back to the raw data or methods, all through the DOI.bio network. Over time, as scientists embrace this, we get a dynamic knowledge base rather than static PDFs on a shelf. It’s easier to discover connections between findings, identify related work, and even find contradictions or gaps because the content is richly interlinked.
• Versioning and Iteration: Since the content lives in a Git-backed environment, updating a publication is as easy as committing a change. Rather than issuing formal corrigenda or new editions, scientists can iteratively improve their documents. Each version can be tracked (and even assigned a new DOI if needed for major revisions) but the barrier to improvement is low. This could lead to a culture of living papers — documents that are continuously updated with new data or insights. Imagine a methods paper that keeps getting refined as the technique improves, or a literature review that auto-updates with the latest references every month. The doi.bio infrastructure supports this vision by design. Every identifier can carry rich metadata including references and version history, and the resolver can serve up the latest or specific versions on demand.

All of this contributes to a more interconnected, dynamic, and open infrastructure for science. Instead of knowledge being locked in silos or slowed by lengthy publication processes, we get something closer to the speed of thought. Researchers can communicate more frequently and informally without sacrificing credit (thanks to DOIs) or rigor (thanks to open peer visibility and version control). And because it’s open, the whole world can, in principle, read and build on these contributions without hitting a paywall or needing a subscription.

Join the Movement: Building the Future of Scientific Writing

The open sourcing of doi.bio’s core is an invitation. It’s an invitation to developers to tinker, to suggest improvements, and to shape the tool they want to use for managing scientific knowledge. It’s an invitation to scientists and science enthusiasts to regain control of the publishing process — to set up your own node, start linking your notes, and share insights on your own terms. We’ve provided the engine; now we can all build a community-driven network atop it.

We’re excited to see what you do with your newfound doi.bio superpowers. Whether you’re integrating an embedded molecular viewer into your lab’s knowledge base to wow your colleagues, or you’re a developer hooking up text-mining AI agents to auto-annotate papers, or a citizen scientist just organizing notes about the papers you read — your contributions and feedback will help steer this project. Together, we can iterate toward a publishing ecosystem that is faster, more open, and truly made for the digital age.

To get started, check out the code on GitHub, read the docs in the repository, and run your own instance. If you run into issues or have ideas, open an issue or join our discussion forum (link in the repo). This is just the beginning of a decentralized, interoperable scientific web. By open-sourcing our core, we hope to catalyze a community that will carry this vision forward. Let’s work together to turn scientific publishing from a slow, closed process into a rapid, open collaboration — one Markdown document at a time!

Happy publishing, and welcome to the doi.bio community!