Forem: NanoAPI

Symbol Extraction - Killing Modular Monoliths

Joel Milligan — Thu, 29 May 2025 14:53:29 +0000

Let’s be honest: rewriting legacy systems sucks.

It’s expensive. It’s slow. It’s risky. And it often fails.

At NanoAPI, we’re building a new way forward—one that lets you evolve your system by extracting functionality instead of rewriting everything from scratch. Our goal is to help teams innovate, scale, and adapt without the weight of technical debt dragging them down.

Because legacy systems shouldn’t be anchors - they should be launchpads.

2. Why Is This a Problem?

Most modern software systems weren’t designed—they evolved. Over time, teams change, frameworks become outdated, and business logic sprawls across thousands of lines of code.

The result? Monoliths that no one fully understands. You touch one thing and something else breaks. A single function call could be trivial—or it could power your entire payments pipeline. Good luck figuring out which.

This complexity kills velocity. It paralyzes decision-making. And for leadership, it’s nearly impossible to assess what parts of the system are fragile, valuable, or safe to change.

3. How Do People Solve This Today?

There are two dominant approaches on the market today, and both are painful:

Rewrite Everything (a.k.a. "The Big Rewrite")
Tools like Claudia.js or the Modular Monolith pattern encourage extraction though rebuilding around modern paradigms (e.g. serverless), but this typically demands a full migration and deep re-architecting. Even if it starts small, it spirals into years of work. Rewrites introduce regressions, delay product roadmaps, and often stall out before delivering value. A middle-ground approach often used here is the manually-driven Strangler Pattern, which still requires years of effort.
Apply AI to Understand Codebases
The promise is tempting: use LLMs to analyze your code and tell you what’s important-or even better, rewrite the whole damn thing for you. But there’s a catch—context windows are too small for real-world monoliths. AI tools may hallucinate, struggle to maintain consistency across files, and miss deeper structural relationships. You end up with surface-level insights, not surgical extractions.

Both options feel like hacking through a jungle with a butter knife.

4. NanoAPI's Solution – Symbol Extraction

At NanoAPI, we believe the right abstraction layer is the symbol.

We built a platform that helps teams extract critical functionality from legacy codebases by analyzing symbols—functions, classes, and variables—mapped into an architectural graph.

This process, which we call symbol extraction, lets you isolate self-contained pieces of your system, see how they depend on each other, and surgically extract or modularize them with confidence.

No rewrites. No guesswork. Just precision tooling for technical debt.

5. What Are Symbols?

In software, a symbol is any named element in your code: a function, class, variable, or module. These are the building blocks of your system’s logic.

Think of them like DNA for your application. Each symbol contains business logic, and together they form complex, interdependent behavior.

By analyzing symbols and how they reference each other, we can reconstruct a living architecture of your codebase—one that’s often more accurate than documentation or diagrams ever were.

6. What Is the Benefit of This Approach Over Other Tools?

Symbol extraction has several key advantages over conventional methods:

It’s deterministic. We don’t guess. We analyze. Our system maps your code’s actual behavior, not just inferred patterns.
No need to rewrite. Our tool is integrated in 5 minutes: instead of migrating everything over years, you selectively extract what matters right away.
Architecture lives in code. Forget stale diagrams—your architecture becomes queryable, visual, and up-to-date.
Safe, modular extraction. You can break down a monolith into clean components without introducing regressions.
Clarity at scale. From a single function to a sprawling app, you get an interactive map of what your code is doing and why.

This is not just code transformation—it’s code as architecture.

7. What Are the Outcomes for Teams and Tech Leadership?

For engineering teams, NanoAPI means:

Understanding dependencies instantly
Knowing what’s safe to extract and what’s tightly coupled
Preserving core logic while shedding dead weight
Making real progress on tech debt without fear

For tech leadership, it means:

Accelerating innovation without rewriting from scratch
Unlocking architectural visibility across teams and services
Bridging the gap between today’s monoliths and tomorrow’s modular systems
Making informed decisions on investment, risk, and scaling

As companies shift toward serverless or modular monolith architectures, NanoAPI becomes the evolution engine—not a rip-and-replace tool, but a precision scalpel.

8. How You Can Help

We’re building NanoAPI in the open—with engineers, architects, and teams like yours in mind.

Here’s how you can get involved:

Try our open-source tool and give us feedback: github.com/nanoapi-io/napi
Join the community on Discord
Contribute use cases or PRs
Talk to us about using NanoAPI in your migration or modernization efforts

Together, we can turn legacy systems from roadblocks into runways—and bring architecture in line with reality.

Want More Information or Help Get Involved?

If you’re facing architectural bottlenecks, uncertainty in legacy systems, or need help guiding technical transformation, NanoAPI can help.

We’d love your feedback, ideas, and contributions.

🌐 nanoapi.io
🔍 docs.nanoapi.io - Our documentation
🐙 GitHub Repo — star us ⭐
📬 Reach out via email — we’re always happy to connect
👾 Join our Discord community!

NanoAPI v1.0.9: Migration to Deno & Performance Boost 🚀

Joel Milligan — Mon, 26 May 2025 08:45:40 +0000

We're excited to announce the newest release of NanoAPI v1.0.9! This release represents a massive architectural overhaul with our migration from Node.js to Deno, which delivers substantial performance improvements and a streamlined development experience.

🎯 What's New in v1.0.9

Deno Migration & Performance Revolution

We've rebuilt NanoAPI to leverage Deno's modern capabilities:

Native Deno modules to replace all Node.js dependencies, dramatically reducing bundle size
Migrated from Express to Oak framework (JSR:@oak/oak) for seamless Deno compatibility
Eliminated some external dependencies (uuid, express, http-proxy-middleware, octokit) in favor of Deno's built-in modules
Adopted JSR registry for standard libraries (@std/path@^1.0.9) to leverage Deno's ecosystem

The improved performance is noticeable immediately, due to faster startup times and a reduction in the overall memory footprint.

Why We Opted for Deno

Deno takes a more modern approach than Node.js, because it enables direct URL imports, which eliminates the need for a package manager
Deno has a commitment to web platform compatibility, and allows browser APIs like Fetch and Web Workers to work natively on the server, creating a unified development experience.
Security is key for Deno - it has a permission-based security model which restricts system access by default, allowing for a more granular control over what applications can do.
Furthermore, it offers built-in testing, formatting, linting, and bundling tools to mean fewer dependencies and a more cohesive development workflow.

A More Streamlined Build & Deployment

We've revamped how NanoAPI is distributed:

The release is now shiiped as Deno executables published on GitHub, instead of the npm registry
A more convenient installation script
Optimized GitHub Actions with faster build times and reduced complexity
Improved our installation documentation to guide you through the upgrade

Enhanced API & Developer Experience

Every aspect of the developer experience has been refined:

Smart version checking with native fetch API and 5-second timeout protection
GitHub-first version verification (goodbye npm registry dependencies)
Cross-platform browser launching using Deno.Command for consistent behavior
Native port detection leveraging Deno's networking APIs

Frontend Modernization

The user interface has received a complete refresh:

Improved Integration:

Seamless API communication between frontend and backend
Optimized routing that works perfectly with Oak middleware
Enhanced file explorer with improved dependency graph connectivity

Modern Components:

Upgraded from bare Radix UI to the comprehensive Shadcn/UI component library
Streamlined UX flows for intuitive user interactions
Better visual feedback and responsive design patterns

🚀 Getting Started with v1.0.9

Ready to experience the new NanoAPI? Here's everything you need to know:

Installation

# Quick install via our convenience script
curl -fsSL https://raw.githubusercontent.com/your-repo/nanoapi/main/install.sh | sh

# Or download directly from GitHub releases
# Visit: https://github.com/your-repo/nanoapi/releases/latest

Migration from Previous Versions

If you're upgrading from an earlier version:

Backup your current configuration - While v1.0.9 maintains API compatibility, it's always good practice
Update your scripts - Replace any Node.js-specific calls with Deno equivalents
Review permissions - Deno's security model may require explicit permission flags

What's Next?

This release sets the foundation for exciting features coming in future versions. We're already working on enhanced TypeScript support, additional built-in utilities, and expanded deployment options.

Do You Have Any Questions or Feedback?

Join our community discussions on GitHub or reach out on our Discord server. We'd love to hear about your experience with the new Deno-powered NanoAPI!

🌐 nanoapi.io
🔍 docs.nanoapi.io - Our documentation
🐙 GitHub Repo — star us ⭐
📬 Reach out via email — we’re always happy to connect
👾 Join our Discord community

We’d love your feedback, ideas, and contributions!

Using NanoAPI on Game Mods

Thea — Wed, 21 May 2025 09:01:41 +0000

Why This Matters

Game mods often evolve into monolithic codebases over time. With the industry shifting toward cloud-native and serverless architectures, tools like NanoAPI help developers to discover dependencies and can help to guide developers to improve these without full rewrites. Here’s how we applied it to the Archipelago Hollow Knight mod.

Note: NanoAPI is compatible with Windows by running it on WSL (Windows Linux Subsystem) at the moment.

Clone the Mod Repo

cd /mnt/c/Mods  # Windows path mounted in WSL
git clone https://github.com/ArchipelagoMW-HollowKnight/Archipelago.HollowKnight

I downloaded the mods into a folder on my Windows partition called C:/Mods, and then in my WSL terminal I am going to the correct directory cd Archipelago.HollowKnight-main/

napi works out of the box on both mac and Linux systems. To use this tool on Windows, you will need to install WSL (Windows Subsystem for Linux) and run the CLI commands from there.
Make sure that Node.js (>=22) and npm are installed https://nodejs.org/en.
Then the command we run is npm install -g @nanoapi.io/napi

⚠️ These warning are to be expected, no worries!

Then we are going to run napi init in the terminal.

Give the backend a minute on first run; C# reflection is 🐢‑slow on big projects.

Then we select the codebase’s language (which in this case is C#)

Then I kept press enter to choose the default ouput file for for NanoAPI

I type “Y”, because I want to use the selected include patterns

I type Y again

I type Y again Because I want to use the code Metrics

Then I kept pressing enter to use the suggested default values of nanoAPI

Now that we have the configuration configured, we’ll run napi audit view

Then there will be a link to a localhost port which we can view in the web browser.

Set up complete

Now this is what our website looks like:

Once set up, you can:

Open the web viewer.
Use the sidebar to explore extracted symbols.
Investigate how each symbol is traced and annotated.
Review warnings such as dependency overloads and decide what to address or ignore.

Finished!

For more information - read the docs: for advanced configs and API extraction.

Want More Information or Help Get Involved?

We’d love your feedback, ideas, and contributions.

🌐 Our website! nanoapi.io
🔍 Our documentation docs.nanoapi.io -
🐙 GitHub Repo — star us ⭐
📬 Reach out via email — we’re always happy to connect
👾 Join our Discord community!

Troubleshooting Notes

I had an issue where it stated
Error: No .csproj files found.

so then I nano'd into .napirc and I manually included .csproj

{
  "language": "c-sharp",
  "project": {
    "include": [
      "**/*.cs",
      "**/*.csproj"  # Added this line
    ],
    "exclude": [ ... ]
  }
}

🚀 Introducing NanoAPI v1.0.6 — Our First Stable Release!

Joel Milligan — Wed, 30 Apr 2025 13:54:07 +0000

We’re excited to announce NanoAPI v1.0.6, the next release of our source-available developer tool focused on building better software architecture in the AI age. In comparison with traditional refactoring tools, NanoAPI gives developers full visibility and control over their architecture, making refactoring easier, safer, and more efficient for everyone.

Whether you’re refactoring legacy code, managing rapid growth, or just aiming for architectural clarity, our open-source tool NanoAPI (napi) is aimed at helping developers, software and solution architects to understand, audit, and evolve their systems—safely and confidently.

Included in this release is support for the following programming languages:

Python
C-sharp

Our documentation is available here.

What is NanoAPI (napi)?

NanoAPI is a versatile tool designed to help to map architectural complexity and enable modular extraction of functionality from large codebases.

Historically, tools like this used to live behind expensive consulting fees. NanoAPI democratizes them, enabling teams of any size to:

🚨 Audit: Pinpoint areas of your code that need refactoring or cleanup.
📝 Refactor: Extract functionality using the UI to improve architecture.
🏗️ Build: Generate modular microservices ready for deployment.
🔍 Architecture: Get a live view of all your software and their interactions; scoped to a specific moment in time.

No more black-box tools. Just open, inspectable, source-available application architecture.

✨ What’s New in v1.0.6?

🔍 Core Engine & Extraction

Improved Python symbol extraction with better handling of partial imports
C# metrics now available for enhanced architectural insights
Enhanced visual representation of nodes for large codebases
Updated highlighting mechanism for better code navigation
New extraction mode with API integration + editable symbol metadata
Fixed Python error AST node cleanup for more reliable extraction

CLI Enhancements

Better version checking with in-terminal update instructions
Fixed static file serving and CLI shebang handling
Streamlined build process for faster execution

Build & Packaging

Moved from external @nanoapi.io/shared to bundled CLI integration
Switched to tsup for more reliable bundling and build performance
Refined workspace configuration and dependency versions

🔧 Core Features (v1.0.6)

✅ Multi-language support (Python, C# — more on the way)
✅ Auto-generated system & code-level diagrams
✅ Audit, refactor, and modularize monoliths
✅ Full visibility into code written by AI or past contributors
✅ Deterministic and inspectable — no black-box logic

Want More Information or Help Get Involved?

If you’re facing architectural bottlenecks, uncertainty in legacy systems, or need help guiding technical transformation, NanoAPI can help.

We’d love your feedback, ideas, and contributions.

🌐 nanoapi.io
🔍 docs.nanoapi.io - Our documentation
🐙 GitHub Repo — star us ⭐
📬 Reach out via email — we’re always happy to connect
👾 Join our Discord community!

We’re source-available first because trust matters, especially when your team’s software architecture is on the line.