iOS Class-Dump & Protocol Analyzer
Paste Objective-C header code or class-dump output to analyze class interfaces, inheritance chains, protocols (with @required and @optional methods), categories, method signatures, and property declarations. The parser visualizes the complete API surface of iOS application code with expandable detail views, inheritance chain mapping, and tab-based filtering by declaration type. All processing is local and private.
Paste Objective-C header code above to analyze class interfaces, protocols, and categories. The parser extracts inheritance chains, method signatures, property declarations, and protocol conformity. Try loading an example to see how it works!
Features
Complete ObjC Header Parsing
Parses the full spectrum of Objective-C declarations: @interface blocks with inheritance (:), protocol conformance (<...>), @protocol with @required and @optional sections, categories (@interface ClassName (Category)), @property declarations with attributes (nonatomic, strong, copy, readonly), instance methods (-) and class methods (+), and instance variables. Handles complex type signatures including blocks, generics (NSArray<NSString *>), and protocol-qualified types.
Inheritance Chain & Protocol Visualization
Automatically builds inheritance chains showing the full class hierarchy from the parsed interfaces. Each class displays its superclass and adopted protocols with clickable badges. Protocol dependencies are shown with parent protocol references. The inheritance view makes it easy to understand the class hierarchy of any iOS framework, library, or application codebase.
Method Signature & Property Detail Views
Expand any class interface to see its complete API surface: properties with attributes and types, instance methods with return types and parameter signatures, class methods (factory methods, singletons), and instance variables. Protocols display @required vs @optional methods with the same level of detail. Categories show their extension methods alongside the original class name.
100% Browser-Local & Private
All parsing and analysis runs entirely in your browser. The Objective-C header code you paste, all parsed interfaces, protocols, categories, method signatures, and property declarations are never uploaded to any server. No API calls, no data collection, no tracking. Completely safe for analyzing proprietary iOS code, third-party libraries, or confidential application headers.
Use Cases
iOS App Reverse Engineering & Analysis
Analyze iOS application headers extracted via class-dump or other Mach-O analysis tools. Understand the complete class hierarchy of any iOS app, including private frameworks, third-party SDKs, and the main application binary. Identify all classes, their superclasses, protocols they adopt, methods they implement, and properties they expose.
Private API Research & Documentation
Explore private iOS/macOS framework headers to discover undocumented classes, methods, and properties. The analyzer helps researchers understand the structure of private frameworks like SpringBoardServices, MobileCoreServices, and GraphicsServices by parsing class-dump output and presenting the API surface in a clean, navigable format.
SDK & Library Integration Planning
When integrating third-party iOS SDKs or libraries, paste the header files into the analyzer to quickly understand the API surface. See the inheritance hierarchy, protocol adoptions, and complete method/property listings at a glance. Compare similar classes across different SDK versions to identify API changes.
Jailbreak Tweak & Theos Development
Jailbreak developers use class-dump extensively to understand the classes they need to hook for tweaks. The analyzer makes it easy to browse interface declarations, find the right methods to swizzle, and understand property types for hooking with Theos or Cydia Substrate. Essential for iOS reverse engineering on a budget.
Learning Objective-C Runtime & Patterns
Computer science students and iOS developers use the analyzer to learn Objective-C runtime patterns. See how Apple designs class hierarchies with protocol-oriented programming, how delegation patterns are declared through formal protocols, and how categories extend classes without subclassing.
Obfuscated Class Structure Discovery
When analyzing obfuscated iOS applications, the class-dump output reveals the class structure even when symbol names are scrambled. The analyzer helps identify the core classes, understand the architecture despite obfuscation, and map out the application's object graph from the remaining structural information.
About iOS Class-Dump & Protocol Analysis
What is class-dump and why is it important?
class-dumpis a command-line tool that examines the Objective-C segment of Mach-O binaries (iOS/macOS executables) and generates corresponding Objective-C header files. It works because Objective-C is a highly introspective language - class names, method names, property names, and protocols are stored as metadata strings in the binary's __objc_classlist,__objc_protolist, and __objc_catlist sections. Our iOS Class-Dump/Protocol Analyzersimulates this by parsing class-dump output or raw Objective-C header files, presenting the class hierarchy, protocol definitions, and API surface in a clean, navigable interface. This is essential for understanding how iOS frameworks work internally, analyzing third-party applications, and reverse engineering iOS software.
How Our Class-Dump Analyzer Works
- Paste or load header data: Paste Objective-C header code from class-dump output, extracted headers, or your own source code. The parser handles @interface, @protocol, and @category declarations with full inheritance and protocol conformance.
- Automatic parsing and extraction: The analyzer reads all declarations and extracts class names, superclasses, adopted protocols, methods (both instance and class), property declarations with attributes and types, instance variables, and optional vs required protocol methods. Inheritance chains are built automatically.
- Explore and analyze results: Browse all declarations through filterable tabs (All, Classes, Protocols, Categories). Expand any class to see its complete API surface. View inheritance chains, protocol hierarchies, and method signatures with return types and parameter names. Copy the analysis report for documentation.
Understanding Objective-C Declaration Types
- @interface (Class Interface): Declares a class with its superclass (inheritance via colon syntax) and adopted protocols (in angle brackets). Contains instance variables in braces, @property declarations for public API, and method declarations with return types and parameters.
- @protocol (Protocol Definition): Declares a formal protocol that classes can adopt. Methods marked @required must be implemented by conforming classes, while @optional methods can be selectively implemented. Protocols can also declare @property requirements.
- @interface (Category):Extends an existing class with additional methods without subclassing. Written as @interface ClassName (CategoryName), categories can add methods and properties to any class - including framework classes where you don't have the source code.
- Method & Property Declarations: Instance methods are prefixed with -, class methods with +. Method signatures use colons for parameters with descriptive labels. Properties use @property with attributes in parentheses (nonatomic, strong, copy, readonly, assign, weak, getter, setter) followed by the type and name.
Privacy, Security & Usage Notes
The iOS Class-Dump/Protocol Analyzer processes all data entirely in your browser using JavaScript. No Objective-C header code is ever uploaded to any server, stored in any database, or shared with any third party. There are no file size limits. The tool is completely free with no signup, no usage limits, and no premium tier. Use it for any purpose - personal, commercial, educational, or security research - at no cost. The analyzer is designed for educational and research purposes to help developers understand iOS application structure and Objective-C runtime behavior.
Related iOS & Swift Tools
Swift Deobfuscator / Symbol Restorer
Detect and reverse Swift obfuscation techniques including short identifiers, hex escapes, Base64, and Data/String patterns.
Swift String Obfuscator
Obfuscate Swift string literals using hex byte arrays, Data + Base64 encoding, XOR encryption, Unicode scalars, and split concatenation.
Swift Identifier Obfuscator
Replace Swift class, struct, enum, function, and variable names with short obfuscated names while preserving keywords and @objc attributes.
Mach-O Binary Analyzer
Parse and analyze Mach-O headers, FAT universal binaries, CPU architectures, load commands, segments, and symbol tables.
Frequently Asked Questions About iOS Class-Dump Analysis
class-dump is a command-line tool that generates Objective-C header files from Mach-O binaries (iOS/macOS .app executables, .dylib, .framework bundles). It works by parsing the Objective-C metadata sections stored in the binary's __DATA segment: __objc_classlist, __objc_protolist, __objc_catlist, and __objc_selrefs. Because Objective-C is a dynamic runtime language, all class names, method names, property names, and protocol conformance information are stored as strings in the binary. class-dump reads this metadata and reconstructs the original @interface, @protocol, and @category declarations with their methods and properties.
The analyzer parses three main declaration types. @interface ... @end blocks for class declarations including inheritance (: SuperClass) and protocol conformance (<Protocol1, Protocol2>), with instance variables, @property declarations, and instance/class methods. @protocol ... @end blocks for protocol definitions with @required and @optional sections, method declarations, and @property requirements. @interface ClassName (CategoryName) ... @end blocks for categories that extend existing classes with additional methods and properties.
No. This is a browser-based parser that analyzes Objective-C header text - it does not run the actual class-dump tool on compiled Mach-O binaries. To use this tool, you first need to run class-dump (or a similar tool like Hopper, Ghidra, or otool) on an iOS/macOS binary to generate the Objective-C header output, then paste that output into our analyzer. The analyzer then visualizes and organizes the parsed declarations in a clean, navigable interface.
You need a jailbroken iOS device or a decrypted IPA to run class-dump. On macOS, install class-dump via Homebrew (brew install class-dump), then run: class-dump -H /path/to/YourBinary -o /output/directory/. For iOS binaries, you first need to decrypt the App Store binary using a tool like dumpdecrypted or Clutch. For macOS applications, you can run class-dump directly on the .app bundle executable. The generated .h files can then be pasted into our analyzer for visualization.
In Objective-C protocols, @required methods must be implemented by any class that adopts the protocol, while @optional methods can be implemented selectively. The @required directive is the default in Objective-C protocols. When analyzing protocol output, the analyzer separates required and optional methods into distinct sections, making it clear which methods are mandatory for protocol conformance and which are optional extensions. This is important for understanding delegation patterns in iOS frameworks.
The analyzer automatically builds inheritance chains by following the superclass (: SuperClass) declaration of each @interface. For example, if you have @interface MyViewController : UIViewController, @interface UIViewController : UIResponder, and @interface UIResponder : NSObject, the analyzer will display: MyViewController → UIViewController → UIResponder → NSObject. This makes it easy to understand the complete class hierarchy and identify which methods are inherited from which superclass.
Indirectly. Swift classes that inherit from NSObject or use the @objc attribute are accessible to the Objective-C runtime and will appear in class-dump output with their Objective-C-compatible signatures. However, pure Swift classes with no Objective-C bridge will not appear in class-dump output. Our analyzer is designed for Objective-C header syntax. For pure Swift code analysis, use our Swift Deobfuscator tool instead.
Yes - 100% free with no signup, no account, and no usage limits. Analyze as many Objective-C headers as you need, as many times as you want. There are no premium tiers, hidden charges, or rate limits. The tool runs entirely in your browser - your code never leaves your device.
Common applications include: understanding private iOS framework APIs for research purposes, discovering undocumented methods and properties in Apple frameworks, analyzing third-party SDKs before integration, identifying the class structure of malware or suspicious iOS apps, creating tweaks and modifications for jailbroken iOS devices, generating API documentation for closed-source libraries, and learning Objective-C patterns by studying how Apple designs their frameworks.