Estimating how much pre-1995 code is still in use today in libraries and firmware is challenging due to the hidden and embedded nature of such code. However, several factors indicate that a significant amount of this legacy code persists:

1. Embedded Systems: Many embedded systems, such as those in medical devices, industrial machinery, and older consumer electronics, often run on firmware developed decades ago. These systems are not frequently updated due to their stability and critical nature.
2. Legacy Software: Older software libraries, especially those written in languages like C and C++, are often integrated into modern applications. Examples include standard libraries, cryptographic functions, and network protocols.
3. Mainframe Systems: Financial institutions, government agencies, and large corporations still rely on mainframe systems running COBOL and other legacy languages. These systems have been in use since the 1960s and 1970s and are deeply embedded in critical operations.
4. Networking Protocols: Core internet protocols like TCP/IP, developed in the 1970s and 1980s, still form the backbone of modern networking. Many of the implementations of these protocols have roots in pre-1995 code.
5. Operating Systems: Legacy code can be found in the kernels of operating systems like Unix, which has been developed since the 1970s. Many modern Unix-like operating systems, including Linux, carry forward portions of this original codebase.
6. Cryptographic Libraries: Some cryptographic algorithms and libraries designed in the early days of computing are still in use today, often embedded within modern software for backward compatibility.

Examples and Notable Mentions

• GNU C Library (glibc): Parts of glibc, which is essential for many Linux systems, date back to the early 1990s.
• OpenSSL: Initially released in 1998, OpenSSL builds upon earlier cryptographic libraries and standards from the pre-1995 era.
• Networking Stacks: Many networking stacks in operating systems have evolved from implementations dating back to the early days of ARPANET.

Challenges and Implications

• Security Risks: Legacy code can harbor vulnerabilities that were unknown or less understood at the time of writing, posing security risks in modern contexts.
• Maintenance: Maintaining and updating legacy code requires specialized knowledge, which can be scarce as older generations of programmers retire.
• Compatibility: Ensuring compatibility with legacy systems often necessitates keeping old code in use, even when more modern solutions are available.

Conclusion

While it’s difficult to quantify precisely how much pre-1995 code remains in use, it’s clear that a substantial amount still operates under the hood of many modern systems. This hidden legacy continues to influence the stability, security, and functionality of contemporary technology.