Visualizing the Slope: Introducing the m-vis Real-Time Leak Delta Chart

SickleFire — Tue, 09 Jun 2026 11:14:35 +0000

Debugging memory leaks by watching a wall of flashing text numbers is a guessing game. You can see the numbers moving, but you entirely miss the trends, spikes, and rhythm of your application.

To solve this, m-vis has introduced: the Real-Time Leak Delta Chart.

By translating raw allocation differentials into a live, scrolling historical timeline right inside your terminal, m-vis shifts memory debugging from a game of parsing numbers to simple, immediate pattern recognition.

What is the Leak Delta Chart?

The Leak Delta Chart is a dedicated visual component in the TUI that maps the output of the core LeakDelta engine over time. Instead of showing you the total size of your application's memory, it charts the net balance of every single cycle (Allocated Bytes minus Freed Bytes).

The chart centers around a Zero Baseline Axis:

Above the Axis (Positive): Represents net memory accumulation (the app claimed bytes it didn’t return).
Below the Axis (Negative): Represents net memory reclamation (the app actively cleaned up more than it took).

What it looks like in your terminal:

This graph illustrates an application experiencing a persistent memory leak. The steady upward trend above the baseline indicates that memory is continuously being allocated but not properly released.

Try it Out

m-vis is built to be simple to use, lightweight, and completely cross-platform.

If you want to move past parsing raw text numbers and actually see your memory behavior, check out the project on GitHub:

Check out m-vis on GitHub

Let me know what you think in the comments, or what features you'd love to see added to the TUI next!

Mvis: Memory Debugging Made Simple and Accessible

SickleFire — Sun, 03 May 2026 16:25:43 +0000

Debugging memory leaks has always been one of those tasks developers dread.

Tools like Valgrind or WinDbg are powerful, but they’re either platform‑specific or too complex for quick diagnostics. I wanted something different: a tool that gives developers answers fast.

That’s the philosophy behind Mvis — a Rust‑based memory visualizer and leak detector.

Why Mvis

Mvis is built around three guiding principles:

Simplicity: One command should be enough to get useful insights.

Accessibility: Debugging shouldn’t be locked behind steep learning curves.

Cross‑platform: Whether you’re on Windows or Linux, the workflow should feel the same.

Or as I like to put it:
“One command. All platforms. No configuration hell.”

What it can do

Even in its early stage, Mvis already supports:

Process scanning: Inspect allocations of active processes.
Heap‑level analysis: See heap structures in detail.
DLL tracking: Monitor loaded libraries.
Leak detection: Identify processes with growing, unreleased allocations.
Stack tracing: Capture call stacks to pinpoint allocation sources.

Supported OS: Windows and Linux.

Quick Usage Examples

# visualize memory map
mvis scan myapp.exe -a

# detect leaks
mvis leak leaking_app.exe 10

# multi-sample leak detection
mvis leak-m myapp.exe 10 3

Outputs are clear and exportable to JSON(Scan), making analysis and visualization easy.

Example: Leak Detection

mvis leak leaking_app.exe 10

Insights

One of the first problems I encountered was:

How do I make Mvis work on both Windows and Linux?

The answer turned out to be simple: platform abstraction.
Mvis defines abstractions for memory regions and heap blocks, which means the core logic doesn’t depend on OS‑specific quirks.

Because of this design, it’s possible to extend support to other platforms in the future — as long as they implement the same abstraction layer Mvis uses..

Roadmap

Mvis is still early but functional. Here’s what’s coming next:

TUI frontend for heap analysis (lightweight by design).
Heap fragmentation visualization.
Realtime heap scanning.
macOS support.
Performance improvements.

Try it out

SickleFire / m-vis

lightweight cross-platform memory visualizer tool

mvis

mvis: Memory debugging for developers who just want answers Simple. Fast. Works everywhere.

Why mvis?

Existing tools are either platform-specific (Valgrind, WinDbg) or too complex for quick diagnostics. mvis gives you memory insights with a single command on any platform.

Our design philosophy is built around simplicity and accessibility because We believe memory debugging should be accessible, not a PhD requirement.

"One command. All platforms. No configuration hell."

Status

Early but functional. Core scanning and leak detection work on both platforms. See the roadmap below for what's coming.

Features

Process Scanning: Inspect memory allocations of active processes.
Heap-Level Analysis: Dive into heap structures for detailed debugging.
DLL Tracking: Monitor and list all DLLs loaded by a target.
Memory Leak Detection: Identify and monitor processes with growing, unreleased allocations.
Stack Tracing: Capture call stacks to pinpoint allocation sources and trace execution paths.
Supported OS…

View on GitHub

Feedback, contributions, and ideas are welcome. Let’s make memory debugging easier for everyone.

DEV Community: SickleFire