# I got tired of scrolling through big Python files, so I made a mind map for code — retained record

> Retained reddit record from reddit:developersIndia.

Canonical: https://highsignal.app/data/records/a7899eb1fa9dfa3c

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:developersIndia)  published 2026-10-10 16:06 ingested 2026-10-11 02:37

[original source ↗](https://www.reddit.com/r/developersIndia/comments/1x2iyqv/i_got_tired_of_scrolling_through_big_python_files/)

## retained text



```
You know when you're debugging a big file, find the function you need, follow it to another function, then another one, and completely forget where you started?

Yeah. I got tired of that, so I built **epy (Extended Python)**. Though, this is experimented only for python, i will explore other languages if possible. 

It's basically a mind map for your code, except the nodes contain actual code instead of just names.

* Parses Python files using `ast` and splits them into blocks with exact line numbers.
* Maps function calls across files, including methods and some class relationships.
* Has a radial map, a names-only view, a folder explorer, and a synced code pane.
* Click a function and see what it calls and what calls it. Click a line in the code and it'll select the corresponding block on the map.

The other thing I wanted was to make life easier for small local LLMs. Instead of dumping an entire file into a model and hoping it doesn't rewrite half of it, epy generates a text map and lets you pull individual blocks with their callers and callees. The idea is to give the model the structure first, then only the code it needs.

I tested it on one of my projects: **33k lines, 134 files, \~1,100 call links, built in about 1.5 seconds.**

It's currently a single Python file with no external dependencies.

    python epy.py view some_file.py
    python epy.py map .
    python epy.py show . MyClass.run

It's still a personal tool, not some polished production-ready package. The call graph is static and best-effort, and I haven't formally benchmarked the LLM side yet.

The idea originally came from the execution model of a small language I'm building (EPL). Eventually, I'd like to add Tree-sitter so it can support other languages too.

Repo: [https://github.com/phoenix2610/Extended\_Programming.git](https://github.com/phoenix2610/Extended_Programming.git)

Would love some feedback, especially if you try it on a ridiculously large Python file or feed the generated map to a small local model. Curious to see where it breaks. 😅

And if anyone is wondering, yeah I am using ARCH Linux and the background bit faded is just a keybinder for opacity... 
```



document fetched 2026-10-11 00:24 · canonical https://reddit.com/r/developersIndia/comments/1x2iyqv/i_got_tired_of_scrolling_through_big_python_files
