Skip to content
🤔 Documentation issue? Report or edit

Shark 🦈

Shark: Smart Heap Analysis Reports for Kotlin

Shark is the heap analyzer that powers LeakCanary 2. It’s a Kotlin standalone heap analysis library that runs at high speed with a low memory footprint.

Shark is released in layers:

  1. Shark Hprof: Read and write records in hprof files.
  2. Shark Graph: Navigate the heap object graph.
  3. Shark: Generate heap analysis reports.
  4. Shark Android: Android heuristics to generate tailored heap analysis reports.
  5. Shark CLI: Analyze the heap of debuggable apps installed on an Android device connected to your desktop. The output is similar to the output of LeakCanary, except you don’t have to add the LeakCanary dependency to your app.
  6. LeakCanary: Builds on top. It automatically watches destroyed activities and fragments, triggers a heap dump, runs Shark Android and then displays the result.

A few more things:

  • Shark is built on top of Okio. Okio makes it easy to parse heap dumps efficiently.
  • Shark is a 100% Kotlin library, and Kotlin is essential to its design, because Shark relies heavily on sealed classes and sequences to save memory.
  • Shark has the unique ability to help narrow down the cause of memory leaks through platform specific heuristics.
  • Shark is heavily tested (80% test coverage).
  • Shark can run in both Java and Android VMs, with no other dependency than Okio and Kotlin.
  • Shark can analyze both Java and Android VM hprof files.
  • Shark can deobfuscate hprof records if it has access to obfuscation mapping file.

Shark CLI

The Shark Command Line Interface (CLI) enables you to analyze heaps directly from your computer. It can dump the heap of an app installed on a connected Android device, analyze it, and even strip a heap dump of any sensitive data (e.g. PII, passwords or encryption keys) which is useful when sharing a heap dump.

Install it via Homebrew:

brew install leakcanary-shark

You can also download it here.

You can then look for leaks in apps on any connected device, for example:

$ shark-cli --device emulator-5554 --process analyze


shark-cli works with all debuggable apps, even if they don’t include the leakcanary-android dependency.

Run shark-cli to see usage instructions:

$ shark-cli

Usage: shark-cli [OPTIONS] COMMAND [ARGS]...

                   ^`.                 .=""=.
   ^_              \  \               / _  _ \
   \ \             {   \             |  d  b  |
   {  \           /     `~~~--__     \   /\   /
   {   \___----~~'              `~~-_/'-=\/=-'\,
    \                         /// a  `~.      \ \
    / /~~~~-, ,__.    ,      ///  __,,,,)      \ |
    \/      \/    `~~~;   ,---~~-_`/ \        / \/
                     /   /            '.    .'
                    '._.'             _|`~~`|_
                                      /|\  /|\

  -p, --process TEXT              Full or partial name of a process, e.g.
                                  "example" would match ""
  -d, --device ID                 device/emulator id
  -m, --obfuscation-mapping PATH  path to obfuscation mapping file
  --verbose / --no-verbose        provide additional details as to what
                                  shark-cli is doing
  -h, --hprof FILE                path to a .hprof file
  --help                          Show this message and exit

  interactive   Explore a heap dump.
  analyze       Analyze a heap dump.
  dump-process  Dump the heap and pull the hprof file.
  strip-hprof   Replace all primitive arrays from the provided heap dump with
                arrays of zeroes and generate a new "-stripped.hprof" file.

Shark code examples

Reading records in a hprof file

dependencies {
  implementation 'com.squareup.leakcanary:shark-hprof:$sharkVersion'
// Prints all class and field names
    .use { hprof ->
          recordTypes = setOf(StringRecord::class),
          listener = OnHprofRecordListener { position, record ->
            println((record as StringRecord).string)
dependencies {
  implementation 'com.squareup.leakcanary:shark-graph:$sharkVersion'
// Prints all thread names
    .use { hprof ->
      val heapGraph = HprofHeapGraph.indexHprof(hprof)
      val threadClass = heapGraph.findClassByName("java.lang.Thread")!!
      val threadNames: Sequence<String> = { instance ->
        val nameField = instance["java.lang.Thread", "name"]!!
      threadNames.forEach { println(it) }

Generating a heap analysis report

dependencies {
  implementation 'com.squareup.leakcanary:shark:$sharkVersion'
// Marks any instance of com.example.ThingWithLifecycle with
// ThingWithLifecycle.destroyed=true as leaking
val leakingObjectFilter = object : LeakingObjectFilter {
  override fun isLeakingObject(heapObject: HeapObject): Boolean {
    return if (heapObject instanceOf "com.example.ThingWithLifecycle") {
      val instance = heapObject as HeapInstance
      val destroyedField = instance["com.example.ThingWithLifecycle", "destroyed"]!!
    } else false

val leakingObjectFinder = FilteringLeakingObjectFinder(listOf(leakingObjectFilter))

val heapAnalysis =
    .use { hprof ->
      val heapGraph = HprofHeapGraph.indexHprof(hprof)
      val heapAnalyzer = HeapAnalyzer(AnalyzerProgressListener.NONE)
          heapDumpFile = heapDumpFile,
          graph = heapGraph,
          leakingObjectFinder = leakingObjectFinder,

Generating an Android heap analysis report

dependencies {
  implementation 'com.squareup.leakcanary:shark-android:$sharkVersion'
val heapAnalyzer = HeapAnalyzer(AnalyzerProgressListener.NONE)
val analysis = heapAnalyzer.checkForLeaks(
    heapDumpFile = heapDumpFile,
    referenceMatchers = AndroidReferenceMatchers.appDefaults,
    objectInspectors = AndroidObjectInspectors.appDefaults