Introduction

This week, the open-source community's spotlight is on "anydoc" by the Firecrawl team, which flawlessly converts 14 formats into Markdown in milliseconds. Alongside this multi-format unified parser, we'll also break down "deepseek-harness" for building local Agent ecosystems, and an extreme optimization practice written in pure C that runs trillion-parameter models on limited memory. More on that in a moment.

---

This Week's Open Source Picks

1. anydoc: An Ultra-Fast Markdown Parser with Unified Output for 14 Formats

• What it is: It solves the pain point of converting Word, PPT, and PDF files to Markdown when building RAG (Retrieval-Augmented Generation), knowledge bases, or document import systems. It first parses 14 formats (including .docx, .pptx, .xlsx, .odt, .rtf, .epub, .csv, .pdf, etc.) into a single unified document model, which is then output by the same Markdown serializer. This ensures that tables and merged cells maintain high consistency across different formats after conversion.
• This Week's Buzz: GitHub 17.9k ★ (a new project within the last 30 days, with 17,894 stars accumulated), licensed under MIT, with Rust as the primary development language.
• Key Features:
  • Extreme Processing Performance: The team conducted benchmarks using 100 real-world documents on an Apple M3 Max with 16GB RAM (see the GitHub benchmark details for data). anydoc achieved a median processing time of just 4.4ms and a quality score of 81. In comparison, Markitdown took 134.8ms (score: 52), Pandoc 102.1ms (score: 38), Docling 513.6ms (score: 51), and Unstructured 572.9ms (score: 63). anydoc is 20 to 250 times faster and is the only tool that successfully passed tests across all 14 formats.
  • Multi-Platform Integration & Lightweight Dependencies: The Rust core offers three integration methods: CLI (npx), Node (@firecrawl/anydoc), and Python (firecrawl-anydoc). It even provides a WebAssembly version (@firecrawl/anydoc-wasm) that can run directly in the browser frontend. Compared to traditional headless LibreOffice conversions, it eliminates the hassle of installing bulky Office software dependencies.
• Quick Start: No installation required—just run this single command in your terminal to try it out:

  npx @firecrawl/anydoc report.docx -o report.md
  

  To integrate it into your development pipeline, install it in your Node project and call it:

  import { toMarkdown } from '@firecrawl/anydoc';
  const markdown = await toMarkdown('report.docx');
  

• Comparison: Compared to Markitdown, Pandoc, Docling, and Unstructured, those tools either lack format coverage (e.g., Pandoc only supports 5/14, Docling 4/14) or are tens to hundreds of times slower. anydoc wins on both format coverage and parsing speed, all without requiring a bloated Office runtime environment.
• Honest Gotchas: Keep in mind its limitations. Currently, it only handles text-based PDFs. For scanned documents or images requiring OCR (Optical Character Recognition), anydoc cannot process them directly; you will need to connect to external services like Firecrawl Parse.
• Who it's for: Backend and AI engineers who are building RAG systems or local knowledge bases and need high-efficiency, high-volume document preprocessing.
• Link: firecrawl/anydoc

---

2. deepseek-harness: A Plugin-Based, Local-First Agent Scaffold Factory

• What it is: A development scaffold designed specifically for engineers who want to build their own AI Agents. It is not an out-of-the-box coding assistant, but rather an "Agent factory" that lets you plug in models, tools, and workflows like building blocks to assemble the Agent you want.
• This Week's Buzz: GitHub 1.8k ★ (Note: This is the standalone star count from the project's early release. The entire official DeepSeek main repository and ecosystem racked up over 180,000 stars in 30 days. This project is a new member of that ecosystem and has already spun off several satellite projects, including a desktop client with 18.2k★, a curated plugin list with 11.5k★, and a routing package with 6.6k★), licensed under MIT, with TypeScript as the primary language.
• Key Features:
  • Plugin-Everything Cordis Architecture: The underlying architecture is built on Cordis. Whether it's the model adapter, tool registry, session log, or even the core agent loop itself—everything is a plugin and can be dynamically swapped via configuration files.
  • Local-First & Native Desktop Support: Run npx @deepseek-ai/dsh web to launch the Web UI locally (defaults to <http://127.0.0.1:3080>), making it completely local-first and eliminating the hassle of signing up for cloud services. Additionally, the team released DSH Desktop, which packages the Web UI, host service, and plugin system into native Windows (NSIS) and macOS (DMG) installers. It features a built-in plugin marketplace and system tray integration, is also licensed under MIT, and is completely free.
• Quick Start: To quickly experience the Web UI, simply run this in your terminal:

  npx @deepseek-ai/dsh web
  

  and open 127.0.0.1:3080 in your browser. Users who prefer not to use the terminal can download the DSH Desktop installer directly from GitHub for an out-of-the-box experience.
• Comparison: Unlike finished Agents like Claude Code or Codex, which are ready to write code out of the box, deepseek-harness provides the underlying skeleton. The former gives you a pre-tuned tool; the latter gives you a rifle chassis with interchangeable barrels.
• Honest Gotchas: The official README warns in all caps: "THERE WILL BE COMPATIBILITY-BREAKING CHANGES". It is currently positioned as a Developer Preview, so using it as a production control plane is not recommended, as APIs and configuration formats are subject to change at any time.
• Who it's for: AI application developers who want to deeply customize Agent workflows, integrate proprietary tools, and prefer local deployment.
• Link: deepseek-ai/deepseek-harness

---

3. kimi-k3-in-c: Extreme Memory-Optimized MoE Model Inference in Pure C

• What it is: It solves the pain point of being unable to run trillion-parameter models on consumer-grade hardware. Written in pure C99 with zero GPU dependencies or frameworks, this project squeezes a 2.78-trillion-parameter model into just 8.24GB of RAM, detailing the math and memory calculations step-by-step in its documentation.
• This Week's Buzz: GitHub 6.3k ★ (a new project within the last 30 days, with 6,267 stars accumulated), licensed under Apache-2.0, with C as the primary language.
• Key Features:
  • Extreme MoE Sparsity & Disk Streaming: The core technique pushes Mixture of Experts (MoE) sparsity to its absolute limit. For each token, only 16 out of 896 experts (just 3.7%) are activated per layer. The remaining 96.3% of the parameters are never loaded into RAM; instead, they reside on disk and are streamed in real-time using an LRU cache. After quantization, the routed experts take up only 0.53 bytes per parameter, while the dense layers are packed into a single 109GB trunk file, accessed via seek operations using a sliding window at known offsets.
  • Extremely High Disk I/O Requirements: Because up to 96.3% of the parameters rely on real-time streaming from disk, disk read/write speed is the absolute bottleneck. A PCIe Gen4 NVMe SSD with read speeds of at least 5000 MB/s is highly recommended; otherwise, loading latency will be severe, drastically slowing down inference.
• Quick Start: You don't need to download the full 1.56TB weights to test compilation and basic execution:

  git clone https://github.com/FareedKhan-dev/kimi-k3-in-c
  cd kimi-k3-in-c
  make -j
  make test
  

  The test suite comes with test data and can be up and running in under two minutes. To perform actual text generation, you will need to run download-model.sh and pack-trunk.sh from the project.
• Comparison: While llama.cpp also performs CPU inference, it assumes that the model (even after quantization) can mostly fit into RAM or be loaded via mmap. This project does the opposite, enabling models with parameter counts hundreds of times larger than the available RAM to run, shifting the bottleneck from memory capacity to disk I/O speed.
• Honest Gotchas: Practicality is extremely low; this is purely a technical showcase and textbook demonstration. The author honestly shared the inference speeds: 26.5 seconds/token on an 8GB RAM laptop, 19.8 seconds on a 64GB desktop, and 5.6 seconds on a workstation with 128GB+ RAM. Additionally, running it requires a 1.56TB checkpoint plus a 109GB trunk, totaling about 1.7TB of disk space. It also currently has zero support for macOS, Windows, or WSL.
• Who it's for: Senior systems engineers who want to dive deep into low-level MoE inference engineering, extreme memory optimization, and how large models interact with hardware I/O.
• Link: fareedkhan-dev/kimi-k3-in-c

---

Conclusion

I'm Muyan. This week, we saw breakthroughs in the open-source community across document parsing speeds, modular Agent architectures, and extreme hardware inference. If I had to pick just one tool to adopt in your projects right away, I highly recommend anydoc—it will save you a massive amount of preprocessing time in your RAG pipelines. See you next week in our Open Source Picks newsletter!