An advanced Windows system information fetcher written in C++ — featuring self-healing configuration, modular architecture, compact & detailed modes, and extreme customization.

Built for Windows. Built to last. Built to be shared.

Simplicity is the priority.

• Two user-editable files
• Self-healing engine
• Modular, scalable design
• Clean separation between data, logic, and presentation

BinaryFetch guarantees that the program never crashes due to missing user files.

If a user:

• deletes BinaryArt.txt
• deletes BinaryFetch_Config.json
• runs BinaryFetch for the first time

👉 The engine automatically recreates everything from defaults.

you can modify and customize them safely from,

C:\Users\Public\BinaryFetch\

That’s it.

No profiles. No databases. No complex formats.

Use $n in your BinaryArt.txt file where n is the color number:

Single color per line:

$1⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿

Output: Entire line in red

Multiple colors per line:

$2⠀⣿⣿⣿⣿⣿⣿$3⣿⣿⣿⣿⣿⣿$1⣿⣿⣿⣿⣿⣿

Output: Green → Yellow → Red

No color (default white):

⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿

• Modular system info engine
• Compact mode & expanded mode
• Multi-GPU support
• Multi-monitor support
• Audio input/output detection
• Power & battery detection
• Predictive disk performance
• Clean ASCII rendering pipeline
• Community-shareable profiles (just JSON + ASCII)

BinaryFetch follows a module-per-domain architecture.

Each system category is implemented as an independent class with no side effects.

TOTAL MODULES & SUB-MODULES:

Breakdown:

• Core Modules: 12 (compact mode)
• Detailed Modules: 12 (expanded info)
• Utility Modules: 10 (support/helper classes) Each module has 1-11 sub-modules for specific data retrieval.

BinaryFetch never breaks due to user mistakes. (expect json syntax)

• Missing ASCII art file → recreated from bundled default
• Missing JSON config → recreated from default schema
• Deleted directories → recreated silently
• Corrupted config → safely regenerated

• ✅ First run always succeeds
• ✅ User customization preserved
• ✅ No duplicated logic
• ✅ No orchestration spaghetti
• ✅ Clean single-call API
• ✅ Future-proof modularity

1. Header Module - System banner/logo display
2. Compact Time Module - Real-time clock display
3. Compact OS Module - OS summary
4. Compact CPU Module - Processor overview
5. Compact GPU Module - Graphics card overview
6. Compact Screen Module - Display information
7. Compact Memory Module - RAM usage summary
8. Compact Audio Module - Audio device status
9. Compact Performance Module - System performance metrics
10. Compact User Module - User session info
11. Compact Network Module - Network connection status
12. Compact Disk Module - Storage usage summary

1. Detailed Memory Module - In-depth RAM analysis
2. Detailed Storage Module - Comprehensive disk info
3. Network Info Module - Complete network details
4. Dummy Network Info Module - Fallback network display
5. OS Info Module - Operating system details
6. CPU Info Module - Processor specifications
7. GPU Info Module - Graphics card details
8. Display Info Module - Monitor/display configuration
9. BIOS/Motherboard Info Module - Firmware and hardware details
10. User Info Module - User account information
11. Performance Info Module - System performance metrics
12. Audio & Power Info Module - Audio devices and power status

• Color Customization: 14+ color options per module
• Toggle Controls: Individual enable/disable for each module
• Granular Display: Control over every element's visibility
• Emoji Support: Optional emoji indicators
• Compact/Detailed Views: Multiple display modes
• Theme System: Consistent color scheme across all modules

• Total Configurable Options: 300+ individual settings
• Color Properties: 150+ color configuration points
• Toggle Switches: 80+ enable/disable controls
• Sub-section Controls: 60+ detailed display options
• Customizable Elements: 200+ individually configurable components

• Snapshot form realtime data: e.g. Disk information inlcuding read\write\used
• Hardware Profiling: Detailed component specifications
• Performance Tracking: CPU/GPU/RAM/Disk utilization
• Network Analysis: Connection and speed monitoring
• Storage Analysis: Disk usage and performance metrics
• Display Configuration: Monitor settings and resolutions
• Audio Monitoring: Input/output device status
• User Session Info: Account and computer details
• System Uptime: Runtime tracking
• Power Management: Battery status monitoring

• Modular Design: Independent module enable/disable
• Fallback Systems: Dummy/backup modules like dummy network
• Detailed/Compact Toggle: Two viewing modes for each module type
• Consistent Formatting: Uniform display structure
• Extensible Architecture: Easy addition of new modules
• Cross-Platform Ready: Windows-focused but adaptable

• Colored Brackets/Parentheses: Syntax highlighting
• Separator Lines: Section dividers
• Label/Value Distinction: Clear text differentiation
• Emoji Integration: Visual indicators
• Header Banners: Module identification
• Progress/Status Indicators: Visual performance representation

Total Configurable Components: 400+ individual display elements across 24 main modules with extensive customization options for appearance, content, and functionality.

• Total Classes: 34
• Total Functions: 158
• Total Objects Instantiated: 21
• Total Helper Lambda Functions: 5
• Total Structures: 8

• Functions: 1
• Functions:
  • loadFromFile() - Returns bool (success/failure)

• Functions: 2
• Functions:
  • push(std::string) - Returns void
  • finish() - Returns void

• Functions: 7
• Functions:
  • GetOSName() - Returns std::string (OS name)
  • GetOSVersion() - Returns std::string (OS version)
  • GetOSArchitecture() - Returns std::string (architecture)
  • get_os_kernel_info() - Returns std::string (kernel info)
  • get_os_uptime() - Returns std::string (uptime)
  • get_os_install_date() - Returns std::string (install date)
  • get_os_serial_number() - Returns std::string (serial number)

• Functions: 11
• Functions:
  • get_cpu_info() - Returns std::string (CPU model)
  • get_cpu_utilization() - Returns std::string (usage percentage)
  • get_cpu_speed() - Returns std::string (current speed)
  • get_cpu_base_speed() - Returns std::string (base speed)
  • get_cpu_cores() - Returns std::string (core count)
  • get_cpu_logical_processors() - Returns std::string (logical processors)
  • get_cpu_sockets() - Returns std::string (socket count)
  • get_cpu_virtualization() - Returns std::string (virtualization status)
  • get_cpu_l1_cache() - Returns std::string (L1 cache size)
  • get_cpu_l2_cache() - Returns std::string (L2 cache size)
  • get_cpu_l3_cache() - Returns std::string (L3 cache size)

• Functions: 4
• Functions:
  • getTotal() - Returns std::string (total RAM in GB)
  • getFree() - Returns std::string (free RAM in GB)
  • getUsedPercentage() - Returns std::string (usage percentage)
  • getModules() - Returns std::vector<memory_module> (RAM modules)

• Functions: 1
• Functions:
  • get_all_gpu_info() - Returns std::vector<GPUData> (all GPU info)

• Functions: 1
• Functions:
  • primary_gpu_info() - Returns GPUDetailedData (detailed GPU info)

• Functions: 1
• Functions:
  • process_storage_info(callback) - Returns void (processes via callback)

• Functions: 7
• Functions:
  • get_network_name() - Returns std::string (network name)
  • get_local_ip() - Returns std::string (local IP)
  • get_public_ip() - Returns std::string (public IP)
  • get_locale() - Returns std::string (locale)
  • get_mac_address() - Returns std::string (MAC address)
  • get_network_upload_speed() - Returns std::string (upload speed)
  • get_network_download_speed() - Returns std::string (download speed)

• Functions: 3
• Functions:
  • get_username() - Returns std::string (username)
  • get_computer_name() - Returns std::string (computer name)
  • get_domain_name() - Returns std::string (domain name)

• Functions: 5
• Functions:
  • get_system_uptime() - Returns std::string (system uptime)
  • get_cpu_usage_percent() - Returns std::string (CPU usage %)
  • get_ram_usage_percent() - Returns std::string (RAM usage %)
  • get_disk_usage_percent() - Returns std::string (disk usage %)
  • get_gpu_usage_percent() - Returns std::string (GPU usage %)

• Functions: 1
• Functions:
  • getScreens() - Returns std::vector<ScreenInfo> (screen info)

• Functions: 3
• Functions:
  • get_output_devices() - Returns std::vector<AudioDevice> (audio outputs)
  • get_input_devices() - Returns std::vector<AudioDevice> (audio inputs)
  • get_power_status() - Returns PowerStatus (power/battery info)

• Functions: 5
• Functions:
  • get_bios_vendor() - Returns std::string (BIOS vendor)
  • get_bios_version() - Returns std::string (BIOS version)
  • get_bios_date() - Returns std::string (BIOS date)
  • get_motherboard_model() - Returns std::string (motherboard model)
  • get_motherboard_manufacturer() - Returns std::string (manufacturer)

• Functions: 10
• Functions:
  • getHour() - Returns int (hour 0-23)
  • getMinute() - Returns int (minute 0-59)
  • getSecond() - Returns int (second 0-59)
  • getDay() - Returns int (day 1-31)
  • getMonthName() - Returns std::string (month name)
  • getMonthNumber() - Returns int (month 1-12)
  • getYearNumber() - Returns int (year)
  • getWeekNumber() - Returns int (week number)
  • getDayName() - Returns std::string (day name)
  • getLeapYear() - Returns std::string (leap year status)

• Functions: 4
• Functions:
  • active_audio_input() - Returns std::string (input device)
  • active_audio_input_status() - Returns std::string (input status)
  • active_audio_output() - Returns std::string (output device)
  • active_audio_output_status() - Returns std::string (output status)

• Functions: 4
• Functions:
  • getOSName() - Returns std::string (OS name)
  • getOSBuild() - Returns std::string (OS build)
  • getArchitecture() - Returns std::string (architecture)
  • getUptime() - Returns std::string (uptime)

• Functions: 4
• Functions:
  • getCPUName() - Returns std::string (CPU name)
  • getCPUCores() - Returns std::string (core count)
  • getCPUThreads() - Returns std::string (thread count)
  • getClockSpeed() - Returns std::string (clock speed in GHz)

• Functions: 3
• Functions:
  • get_total_memory() - Returns std::string (total RAM in GB)
  • get_free_memory() - Returns std::string (free RAM in GB)
  • get_used_memory_percent() - Returns std::string (RAM usage %)

• Functions: 1
• Functions:
  • getScreens() - Returns std::vector<CompactScreenInfo> (screen info)

• Functions: 0 (declared but not used in current code)

• Functions: 4
• Functions:
  • getGPUName() - Returns std::string (GPU name)
  • getGPUUsagePercent() - Returns std::string (GPU usage %)
  • getVRAMGB() - Returns std::string (VRAM in GB)
  • getGPUFrequency() - Returns std::string (GPU frequency)

• Functions: 4
• Functions:
  • getCPUUsage() - Returns std::string (CPU usage %)
  • getGPUUsage() - Returns std::string (GPU usage %)
  • getRAMUsage() - Returns std::string (RAM usage %)
  • getDiskUsage() - Returns std::string (disk usage %)

• Functions: 3
• Functions:
  • getUsername() - Returns std::string (username)
  • getDomain() - Returns std::string (domain)
  • isAdmin() - Returns std::string (admin status)

• Functions: 3
• Functions:
  • get_network_name() - Returns std::string (network name)
  • get_network_type() - Returns std::string (network type)
  • get_network_ip() - Returns std::string (IP address)

• Functions: 2
• Functions:
  • getAllDiskUsage() - Returns std::map<std::string, double> (drive:usage%)
  • getDiskCapacity() - Returns std::map<std::string, double> (drive:capacity GB)

• Functions: Not instantiated in main

• These headers are included but their classes aren't instantiated in main:
  • CompactSystem
  • DetailedScreen
  • Various other headers in includes

• Fields: capacity, type, speed

• Fields: gpu_name, gpu_memory, gpu_usage, gpu_vendor, gpu_driver_version, gpu_temperature, gpu_core_count

• Fields: name, vram_gb, frequency_ghz

• Fields: drive_letter, total_space, used_space, used_percentage, file_system, is_external, serial_number, read_speed, write_speed, predicted_read_speed, predicted_write_speed, storage_type

• Fields: name, current_width, current_height, native_resolution, refresh_rate, aspect_ratio, scale_percent, upscale, dsr_enabled, dsr_type

• Fields: name, isActive

• Fields: hasBattery, batteryPercent, isCharging

• Fields: name, native_width, native_height, scale_percent, upscale, refresh_rate

• Returns: std::string (ANSI color code)
• Parameters: section, key, defaultColor

• Returns: bool (section enabled status)
• Parameters: section

• Returns: bool (subsection enabled status)
• Parameters: section, key

• Returns: bool (nested section enabled status)
• Parameters: module, section

• Returns: bool (deep nested config enabled status)
• Parameters: module, section, key

• String Returns: 121 functions (76.6%)
• Vector Returns: 6 functions (3.8%)
• Map Returns: 2 functions (1.3%)
• Structure Returns: 8 functions (5.1%)
• Boolean Returns: 1 function (0.6%)
• Void Returns: 6 functions (3.8%)
• Integer Returns: 10 functions (6.3%)
• Callback-based: 1 function (0.6%)

1. String Dominance: Most functions (76.6%) return strings for easy display formatting
2. Modular Design: Each class has a specific, focused responsibility
3. Data Structures: Well-defined structures for complex data types
4. Configuration Integration: All output is JSON-configurable via helper functions
5. Separation of Concerns: Compact vs Detailed modules for different display needs

Q: What about the Linux version of Binary Fetch?
A: The Linux version is currently under development.

Q: Will Linux users get the same features as the Windows version?
A: Yes, Linux will have all the features of the Windows version — and potentially more.

Q: Does Binary Fetch share user data?
A: No. Binary Fetch does not collect or share any user data.

Q: Does Binary Fetch run in the background?
A: No. Binary Fetch is a CLI tool and only runs when the command is executed in the terminal.