Hardware-Lab on Tech Blog

Complete Guide to Fiber Optic Communication — From Principles to Real-World Use

Thu, 16 Apr 2026 10:00:00 +0900

Fiber optic communication transmits data using light as the medium. Commercialized in the 1970s, it has since become the backbone of the internet, transoceanic cables, and data center networks. With transmission speeds thousands of times faster than copper and reach extending tens of kilometers, modern communications infrastructure simply cannot function without fiber optics.

1. Core Principle — Total Internal Reflection (TIR)
#

The physical foundation of fiber optics is Total Internal Reflection (TIR). When light travels from a medium with a higher refractive index (the core) to one with a lower index (the cladding), it completely reflects back if the angle of incidence exceeds the Critical Angle — no light escapes.

Building an NVIDIA GPU Controller (5) — EDID Editor and Color Control Complete

Fri, 27 Mar 2026 13:00:00 +0900

This is the final installment of the series. We’ve covered NVAPI initialization, GPU and display information queries, and custom resolutions up to this point. Now we implement the project’s highlights — the EDID editor and color control — and bring the entire application to completion.

What Is EDID Editing
#

EDID (Extended Display Identification Data) is a 128-byte (or 256-byte+ for extensions) structure that a monitor uses to advertise its capabilities to the graphics card. It is exchanged automatically over the DDC/CI channel upon connection, and the GPU driver uses this data to determine supported resolutions, color depth, HDR support, and more.

Building an NVIDIA GPU Controller (4) — Custom Resolutions and Display Timing Calculations

Fri, 27 Mar 2026 12:00:00 +0900

Previous parts of this series covered NVAPI initialization, GPU information queries, and EDID reading and writing. This part tackles the project’s core feature: custom resolutions. Rather than simply calling NVAPI functions, the goal is to calculate and apply display timing directly — the language that monitors actually understand.

What Is Display Timing
#

When a monitor and GPU exchange pixel data, they don’t just pass around resolution numbers. The analog signal conventions from the CRT era carried over into the digital world, so beyond the visible pixels that make up the image, there are defined blanking intervals on all sides.

Building an NVIDIA GPU Controller (3) — Deep Dive into EDID Binary Structure and Parsing

Fri, 27 Mar 2026 11:00:00 +0900

In the previous installment we covered initializing NVAPI and obtaining GPU handles along with display Output IDs. This entry is the most technically dense in the series. We’ll dissect the EDID byte array retrieved from an NVIDIA GPU — byte by byte — examining exactly what structure it encodes and how our C# parser interprets it.

What Is EDID?
#

EDID (Extended Display Identification Data) is binary data that a monitor sends to the GPU to identify itself and declare what it supports. First standardized by VESA in 1994, the spec has evolved through EDID 1.4 and consists of a 128-byte base block plus optional 128-byte extension blocks.

Building an NVIDIA GPU Controller (2) — GPU Info Query and Display Enumeration

Fri, 27 Mar 2026 10:00:00 +0900

Part 1 covered how to build the NVAPI wrapper layer and pull native functions into C# through NvApiWrapper. This installment focuses on two core modules that actually put that wrapper to use: NvGpuInfo, which collects GPU hardware data, and NvDisplay, which enumerates every connected display and resolves monitor names.

The data structures these two classes produce — GpuInfoData, DisplayInfo, and DriverInfo — are the shared models used throughout the entire controller.

Building an NVIDIA GPU Controller (1) — NVAPI Initialization and Project Architecture

Fri, 27 Mar 2026 09:00:00 +0900

The idea of controlling an NVIDIA GPU programmatically had been sitting in the back of my mind for a while. Reading and writing monitor EDID directly, injecting custom resolutions, changing color space settings with a single line of code — I needed a tool that could push settings directly to the GPU on my own terms, without relying on GeForce Experience or the NVIDIA Control Panel.

The result is NvGpuController — an NVIDIA GPU control application built with C# WinForms (.NET 4.7.2). This series documents the process of building it from scratch. Part 1 covers why I chose NVAPI, how the project is structured, and how I bridged NVAPI’s unusual initialization mechanism into C# via P/Invoke.