ElixirScope - Introspection and Debugging

1. Redid the spec to match vision:

https://github.com/nshkrdotcom/ElixirScope/blob/main/docs/008-g-prd.md

2. See funny highlight using Jules just now on it:

image1200×1696 200 KB

Just released v0.0.1 on hex.

Seems that Mermaid diags do not render on hex; will fix that in a later release:

Public API:

Please do take a look. Kindly provide feedback.

It requires an additional and very simple setup which is covered in the main documentation page, see: Rendering Mermaid graphs | ExDoc @ HexDocs

Great, thanks. Updated.

This is a fairly complex project. Is anyone else interested in working on it? I’m flexible on the product requirements. Development started only three days ago, thus major changes to features/arch are okay at this time.

The scope has expanded to include Graph Generators for CFG, DFG, CPG.Tests are passing for these features. >1,000 passing tests thus far.

Please see current docs on the github.

Next up is a broad stabilization effort via code review, cleanup, refactoring, warning analysis, runtime error fixes, and significant expansion of all AST-related tests, including CPG components. This milestone will mark the v0.0.2 release.

Once stable, CPG formalization efforts will commence (per docs on github:
“./CPG_*.md”)

As a mere mortal, collaboration would certainly help to accelerate the project. It’s a chance to build an innovative tool in Elixir. LMK! I lt would be a pleasure to formalize tasks for your convenience.

Aloha

The mockup from the last post had over 1,000 passing tests, but lib was over 40,000 LOC. The project became disorganized and unwieldly, thus reviewing new structures for the code base became necessary.

Here’s the revised structure:
https://github.com/nshkrdotcom/elixir_scope/blob/main/DEV.md

I am kindly requesting that a seasoned Elixir engineer review this proposed structure, and provide critical feedback.

Still iterating on the foundation. Learning so much. This is my first attempt to write a non trivial OTP application, so bear with me.

Humbly requesting for a seasoned OTP engineer to review the plans for building the infrastructure layer into the foundation. The ServiceRegistry and ProcessRegistry implementations are done but need test coverage. And the Infrastructure component implementation has not yet commenced. Here’s the proposed design (this link may break down the road):

https://github.com/nshkrdotcom/elixir_scope/blob/main/docs/FOUNDATION_OTP_IMPLEMENT_NOW/10_gemini_plan.md

The original project idea, which was a smaller scale development debugger, wouldn’t need all this infrastructure. So, this project has turned into an educational project more than anything. A reusable foundation for a large scale Elixir app would be nice, too, if possible.

I’d be super humbled if someone with relevant experience could review the above Infrastructure plan and provide constructive critical feedback. So far, all design has been the result of some googling, but mostly prompting Claude/Gemini/Grok.

Revisiting this brainslop (is that a thing? brainstorm slop?) over a year later. Eventually I’ll actually reduce and delete incomplete projects rather than start more. Here, I’ll reuse ElixirScope with some wisdom gained in the past year.

Now that AI has time to settle with the community, there are some fantastic libs to leverage for such a system. What I’m seeking to build, really, is a rapid code/system comprehension and introspection tool. Something like this: how can a human engineer quickly navigate a large Elixir codebase without having to futz with files? Automatic code analysis with useful info/viz, etc. are paramount.

Elixir’s creator has noted (roughly) that code review remains an important moat for a meat proxy. I have yet to see anything resembling a canonical forward-thinking realization of this vision for the BEAM in a state-of-the-art tool – does anyone know what’s in the works? (Surely this is not a unique vision by any means, and there’s a good chance that something great already exists and/or someone is working on this, which is part of the reason for the post).

Anyway, Reach comes to mind as one of the more valuable libs to leverage here:

https://github.com/nshkrdotcom/docs/blob/main/ElixirScope-Blueprint-2026-10/01-research/01-library-landscape.md

Here’s how it could come together, per this GPT-prompted diagram:

https://github.com/nshkrdotcom/docs/blob/main/ElixirScope-Blueprint-2026-10/diagrams/01-architecture.mmd

Given the sophistication of such a project with a large focus on UI/UX, my preference is for a TS/node frontend. I’ve had good success building LiveView to a headless endpoint for this purpose.

Always open to feedback/critiques/ideas. Thanks.