In 1998, a Swedish programmer named Daniel Stenberg released a small command-line tool called cURL — short for “Client URL.” It did one thing: transfer data using internet protocols. There was no graphical interface, no startup funding, no marketing campaign. It was a single-purpose utility that could fetch a web page or upload a file from a terminal. Twenty-seven years later, cURL is installed on virtually every connected device on Earth. It ships with every copy of Windows 10 and 11, every macOS installation, every Linux distribution, every iOS and Android device, every modern automobile infotainment system, and countless embedded devices. Conservative estimates put cURL on more than 10 billion devices worldwide, making it one of the most widely deployed pieces of software in history — alongside the Linux kernel and fundamental libraries like zlib. Every developer who has ever typed curl https://api.example.com into a terminal has used Stenberg’s creation. Every application that relies on libcurl — from PHP and Python to video game consoles and spacecraft — depends on code that one person has maintained, largely as a volunteer, for over a quarter century. Daniel Stenberg never founded a company around cURL, never raised venture capital, and never made millions from the tool that became the backbone of how the internet’s data moves. His story is one of the most remarkable in open source history — a testament to what happens when relentless persistence meets genuine technical excellence.
Early Life and Path to Technology
Daniel Stenberg was born on March 3, 1970, in Huddinge, a municipality in Stockholm County, Sweden. He grew up during the personal computing revolution of the 1980s, and like many future programmers of his generation, he was drawn to computers early. Stenberg got his first computer — a Commodore 64 — as a teenager and quickly moved from playing games to writing code. He learned assembly language, C, and the fundamentals of systems programming through the deeply hands-on, self-directed process that characterized the European demoscene and hobbyist programming communities of that era.
Stenberg studied at the Royal Institute of Technology (KTH) in Stockholm, one of Sweden’s premier technical universities, though he has noted that he did not complete a formal degree — he was too focused on programming. By the early 1990s, he was working as a professional software developer in Sweden, primarily in C and systems-level programming. His early career work involved networking code, embedded systems, and Unix development — the exact skill set that would make cURL possible.
Before cURL, Stenberg was active in the IRC (Internet Relay Chat) community and contributed to various open source projects. In 1996, he discovered a small tool called httpget, written by Rafael Sagula, which could download files over HTTP from the command line. Stenberg started contributing patches to httpget, adding features like FTP support. By 1997, he had become the primary maintainer and renamed the tool to urlget — reflecting its expanded protocol support. In 1998, he renamed it again to cURL (Client URL) and released version 4.0 with a completely rewritten codebase under a permissive open source license. This was the beginning of what would become one of the most consequential software projects in the history of the internet.
The cURL Breakthrough
Technical Innovation
cURL’s genius lies not in any single algorithmic innovation but in its relentless comprehensiveness, correctness, and reliability. At its core, cURL is a command-line tool for transferring data with URLs, and libcurl is the underlying C library that provides the same capabilities as a programmable API. Together, they support an extraordinary range of protocols: HTTP, HTTPS, FTP, FTPS, SFTP, SCP, LDAP, LDAPS, DICT, TELNET, TFTP, IMAP, IMAPS, POP3, POP3S, SMTP, SMTPS, RTSP, RTMP, MQTT, and more. As of 2025, cURL supports over 25 distinct transfer protocols.
The command-line interface is deceptively simple. A basic HTTP GET request is a single command:
# The simplest cURL command — fetch a web page
curl https://example.com
# POST JSON data to an API endpoint
curl -X POST https://api.example.com/users \
-H "Content-Type: application/json" \
-d '{"name": "Daniel", "role": "developer"}'
# Download a file with progress bar and resume support
curl -L -O -C - https://releases.example.com/package-v2.1.tar.gz
# Upload via FTP with authentication
curl -T backup.sql ftp://ftp.example.com/backups/ \
--user admin:secret
# Follow redirects, send custom headers, output response headers
curl -L -v -H "Authorization: Bearer TOKEN" \
-o response.json -D headers.txt \
https://api.example.com/data
# Test API latency with detailed timing information
curl -w "DNS: %{time_namelookup}s\nConnect: %{time_connect}s\nTLS: %{time_appconnect}s\nTotal: %{time_total}s\n" \
-o /dev/null -s https://example.comBut beneath that simplicity is a staggering amount of engineering. cURL handles TLS/SSL (via OpenSSL, GnuTLS, NSS, wolfSSL, Schannel, Secure Transport, and other backends), HTTP authentication (Basic, Digest, NTLM, Negotiate/Kerberos), proxy support (HTTP, HTTPS, SOCKS4, SOCKS5), cookie handling, compressed transfers, multipart form uploads, connection pooling, HTTP/2 multiplexing, HTTP/3 over QUIC, and hundreds of other features. The curl command has over 250 command-line options as of version 8.x. Each of these options represents a carefully implemented, thoroughly tested feature.
The libcurl library is what makes cURL’s impact truly global. Written in portable C89, libcurl provides a stable, well-documented API that can be linked into virtually any application. Bindings exist for over 60 programming languages, including PHP (where cURL is one of the most commonly used extensions), Python (via pycurl), Ruby, Java, Go, Rust, and many others. When a PHP application calls curl_exec() to fetch data from an external API, it is calling libcurl. When a Python script uses pycurl to download a file, it is calling libcurl. When a video game console checks for updates, when a car’s infotainment system streams music, when a smart thermostat contacts its cloud service — in an enormous number of cases, the data transfer is handled by libcurl.
Why It Mattered
Before cURL, developers who needed to transfer data over the internet had to write protocol-specific code or rely on fragmented, platform-dependent tools. There was no single, reliable, cross-platform utility that handled the full range of internet protocols with consistent behavior. wget existed for downloading files over HTTP and FTP, but it was designed for recursive downloading, not for the general-purpose data transfer and API interaction that would become central to modern software development.
cURL filled this gap at precisely the right moment. The late 1990s and early 2000s saw the explosive growth of web APIs, web services (SOAP, then REST), and internet-connected applications. Developers needed a tool to test APIs, debug network issues, automate data transfers, and integrate HTTP communication into their applications. cURL became that tool — both as a command-line utility for quick testing and debugging, and as libcurl for production integration.
The impact on the API ecosystem is particularly significant. Today, virtually every API documentation page includes cURL examples. When Stripe, Twilio, GitHub, AWS, or any other API provider shows how to make an API call, the example is almost always a cURL command. This is not a coincidence — it is because cURL has become the universal language of HTTP interaction. It is the lingua franca that every developer understands, regardless of their primary programming language or platform. Modern API design practices, including RESTful architecture, would have evolved differently without a universal tool like cURL to test and demonstrate them.
Other Contributions
While cURL is Stenberg’s defining creation, his contributions to the broader internet ecosystem extend well beyond it.
libcurl as a platform: The decision to separate cURL into a command-line tool and a reusable library (libcurl) was architecturally significant. libcurl is not just a helper for cURL — it is a standalone, embeddable HTTP client library used by thousands of applications. Apple’s operating systems (macOS, iOS, watchOS, tvOS) use libcurl internally. PHP’s cURL extension — one of the most commonly used PHP extensions — is a wrapper around libcurl. The library’s stable API and ABI (Application Binary Interface) guarantee means that applications linked against libcurl years ago still work with current versions without recompilation. This commitment to backwards compatibility is unusual in the software industry and has been a key factor in libcurl’s adoption.
HTTP/2 and HTTP/3 implementation: Stenberg has been deeply involved in the development and implementation of modern HTTP protocol versions. He contributed to the HTTP/2 standardization process (RFC 7540) and wrote one of the earliest and most comprehensive guides explaining the protocol. cURL was one of the first tools to support HTTP/2 in production, and Stenberg’s implementation work helped identify issues in the specification itself. For HTTP/3 — which runs over QUIC instead of TCP — Stenberg has been similarly involved, implementing support in cURL and contributing to the standardization discussion. His practical implementation experience feeds back into the standards process, helping ensure that HTTP specifications are implementable and correct. This work directly supports the evolution of the protocols that power every web browser and web server on the planet.
Open source maintenance as a discipline: Perhaps Stenberg’s most underappreciated contribution is demonstrating what long-term open source maintenance looks like in practice. He has maintained cURL for over 27 years, releasing updates approximately every 8 weeks. As of 2025, cURL has had over 250 releases and Stenberg has personally reviewed or written a substantial majority of the code. He runs the project’s bug bounty program (funded by the Internet Bug Bounty and later by corporate sponsors), manages security vulnerability disclosures with a level of professionalism that matches or exceeds commercial software vendors, and writes detailed blog posts explaining every security issue and fix. His approach to open source project management has become a model for how critical infrastructure software should be maintained.
c-ares: Stenberg also created and maintains c-ares, an asynchronous DNS resolver library in C. While less famous than cURL, c-ares is used by Node.js, libcurl itself, and many other projects that need non-blocking DNS resolution. It is a quietly essential piece of internet infrastructure.
Writing and advocacy: Stenberg is a prolific writer and speaker on internet protocols, open source sustainability, and software security. His book “Everything cURL” is a comprehensive, freely available guide to the tool and library. His blog (daniel.haxx.se) is one of the most widely read sources on HTTP internals and internet protocol development. He has spoken at conferences worldwide, including FOSDEM, Linux Foundation events, and HTTP workshops, educating developers on how internet data transfer actually works. For teams looking to improve their approach to managing complex technical projects, platforms like Taskee can help coordinate the kind of disciplined, long-term maintenance that Stenberg exemplifies.
Philosophy and Engineering Approach
Key Principles
Stenberg’s engineering philosophy can be distilled into several core principles that have guided cURL’s development and shaped its success.
Correctness over speed. cURL’s primary goal has never been to be the fastest data transfer tool — it has been to be the most correct. Stenberg is meticulous about implementing protocols exactly as specified in their RFCs. When cURL encounters an ambiguity in a protocol specification, Stenberg researches the intent, tests against other implementations, and documents the behavior. This commitment to correctness is why cURL is trusted for testing and debugging — developers know that if cURL behaves in a certain way, the protocol specification supports that behavior.
Backwards compatibility is sacred. The libcurl API has maintained backwards compatibility for over two decades. Applications built against libcurl in the early 2000s can still compile and run against the latest version. Stenberg achieves this through careful API design, versioning, and a policy of never removing or changing existing function signatures. New features are added through new functions and options, not by modifying existing ones. This discipline is rare in the software industry, where breaking changes are common, and it has been essential to libcurl’s adoption in embedded systems, operating systems, and long-lived applications where upgrading dependencies is costly.
Portability is non-negotiable. cURL runs on virtually every operating system and hardware platform: Linux, Windows, macOS, FreeBSD, Solaris, AIX, HP-UX, embedded Linux, RTOS systems, and dozens of others. Stenberg has maintained this portability by writing in C89 (later C99), avoiding platform-specific features unless wrapped in abstraction layers, and maintaining an extensive CI/CD system that tests every commit across multiple platforms and configurations. The code compiles with GCC, Clang, MSVC, and numerous other compilers. This is not accidental — it is the result of deliberate, sustained engineering effort.
Security is a first-class concern. Stenberg has made cURL one of the most security-conscious open source projects in existence. The project has a formal security process, a bug bounty program, and a track record of transparent, rapid vulnerability disclosure and patching. Stenberg personally writes detailed CVE advisories for every security issue, explaining the vulnerability, its impact, the fix, and the affected versions. He has processed over 150 CVEs for cURL, and each one is documented with a level of thoroughness that commercial software companies rarely match. In the broader landscape of internet infrastructure, this level of security diligence is essential — cURL handles TLS certificates, authentication credentials, and sensitive data for billions of devices.
Open source is a commitment, not a business model. For the majority of cURL’s history, Stenberg maintained it while working full-time as an employee at various Swedish companies, dedicating evenings and weekends to the project. In 2019, he joined wolfSSL, a company that provides commercial support for embedded TLS, where maintaining cURL became part of his job. But for the first 21 years, cURL was a volunteer effort. Stenberg has been candid about the challenges of sustaining critical open source infrastructure without sustainable funding, and his experience has been cited in debates about open source sustainability and the “tragedy of the commons” that affects many foundational software projects.
Legacy and Modern Relevance
Daniel Stenberg’s impact on modern computing is disproportionate to his public profile. While figures like Linus Torvalds and Tim Berners-Lee are household names in technology, Stenberg is far less well known outside the developer community — yet his software runs on more devices than almost any other. cURL is in your phone, your laptop, your car, your TV, your router, and your smart home devices. It is in the servers that run cloud computing, in the build systems that produce software, and in the testing infrastructure that verifies it.
The numbers are extraordinary. As of 2025, the cURL project has received contributions from over 1,000 individual developers, but Stenberg remains the project’s single most prolific contributor by a wide margin — responsible for the majority of commits across the project’s history. The cURL repository on GitHub has over 35,000 stars. The tool has been downloaded billions of times. It has been cited in U.S. court proceedings as a standard tool. It is one of the few pieces of software listed in the acknowledgments screens of operating systems from Microsoft, Apple, and Google simultaneously.
cURL’s role in the API economy deserves special emphasis. The shift from monolithic web applications to microservice architectures — where dozens or hundreds of services communicate over HTTP — has made cURL even more central to how software is built and debugged. When a developer needs to verify that an API endpoint returns the correct response, they use cURL. When a DevOps engineer writes a health check script, they use cURL. When a CI/CD pipeline needs to notify a webhook, it frequently uses cURL. The tool has become so fundamental to the developer workflow that it is difficult to imagine modern software development without it.
The libcurl library’s influence is equally pervasive. In the world of embedded systems and IoT (Internet of Things), where devices need to communicate with cloud services but have limited resources, libcurl’s small footprint, configurability, and protocol support make it a natural choice. Automotive manufacturers use libcurl for over-the-air updates. Medical device companies use it for telemetry. Industrial control systems use it for monitoring. In each case, the reliability and security of libcurl directly affects the safety and functionality of physical systems.
Stenberg’s work on HTTP/2 and HTTP/3 ensures that cURL remains at the cutting edge of internet protocol development. As the web transitions to HTTP/3 and QUIC, cURL is again one of the first tools to support these protocols in production, giving developers immediate access to the latest standards. This pattern — implementing new protocols early, testing them thoroughly, and feeding implementation experience back into the standards process — has been consistent throughout cURL’s history and makes Stenberg an important participant in the evolution of the web itself.
In the broader story of open source software, Stenberg represents a particular and important archetype: the solo maintainer of critical infrastructure. The C and C++ ecosystem depends on individual maintainers like Stenberg who keep foundational tools running, secure, and up to date. His advocacy for better funding models for open source maintainers, including the Polarsquad and Open Source Pledge initiatives, highlights the structural challenges facing software that the entire internet depends on but that few organizations directly support.
The following C code demonstrates how libcurl is used programmatically — the same API that powers billions of data transfers daily:
#include <stdio.h>
#include <curl/curl.h>
/* Callback function to handle received data */
static size_t write_callback(void *contents, size_t size,
size_t nmemb, void *userp) {
size_t total = size * nmemb;
fwrite(contents, size, nmemb, (FILE *)userp);
return total;
}
int main(void) {
CURL *curl;
CURLcode res;
/* Global initialization — call once per program */
curl_global_init(CURL_GLOBAL_DEFAULT);
/* Create a session handle */
curl = curl_easy_init();
if (curl) {
/* Set the URL to fetch */
curl_easy_setopt(curl, CURLOPT_URL,
"https://api.example.com/data");
/* Follow HTTP redirects (3xx responses) */
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
/* Verify TLS certificates (always do this!) */
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
/* Set custom headers */
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers,
"Accept: application/json");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
/* Set the write callback */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
write_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
/* Perform the transfer */
res = curl_easy_perform(curl);
if (res != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(res));
}
/* Clean up */
curl_slist_free_all(headers);
curl_easy_cleanup(curl);
}
curl_global_cleanup();
return 0;
}Key Facts
- Born: March 3, 1970, Huddinge, Stockholm County, Sweden
- Known for: Creating and maintaining cURL and libcurl, the most widely deployed data transfer tools in history
- Key projects: cURL (1998–present), libcurl, c-ares (asynchronous DNS resolver), HTTP/2 and HTTP/3 implementation work
- Awards: Polhem Prize (2017, Sweden’s oldest technical award), Nordic Free Software Award (2009), named one of the top 100 innovators in Sweden by NyTeknik
- Education: Studied at the Royal Institute of Technology (KTH), Stockholm
- Career: Various software engineering roles in Sweden (1990s–2019), wolfSSL (2019–present, as cURL lead developer)
- cURL stats (2025): 250+ releases, 25+ supported protocols, 10+ billion device installations, 1,000+ contributors, 35,000+ GitHub stars
- License: cURL is released under the MIT/X-derived license (the “curl license”), one of the most permissive open source licenses
Frequently Asked Questions
Who is Daniel Stenberg?
Daniel Stenberg (born 1970) is a Swedish software developer who created cURL, the command-line data transfer tool, and libcurl, the underlying C library. First released in 1998, cURL has become one of the most widely installed pieces of software in history, running on more than 10 billion devices. Stenberg has maintained the project for over 27 years, making him one of the longest-serving active maintainers of a critical open source infrastructure project. He currently works at wolfSSL, where maintaining cURL is part of his professional role.
Why is cURL installed on so many devices?
cURL’s ubiquity stems from several factors. First, libcurl is written in portable C and supports virtually every operating system and hardware platform. Second, it supports over 25 internet protocols (HTTP, HTTPS, FTP, SFTP, SMTP, and many more) in a single library, eliminating the need for multiple protocol-specific tools. Third, it is released under a highly permissive license (the curl license, derived from MIT) that allows commercial and embedded use without restriction. Fourth, its stable API and ABI guarantee means that integrators can rely on backwards compatibility across versions. These qualities have led Microsoft, Apple, Google, and hundreds of other companies to ship cURL as a standard component of their operating systems, applications, and devices.
How does cURL compare to wget and other tools?
While cURL and wget are both command-line tools for transferring data, they serve different purposes. wget is optimized for recursive downloading — mirroring websites, downloading entire directories — and supports fewer protocols. cURL is designed for single-transfer operations and excels at API interaction, supporting a far wider range of protocols, authentication methods, and options. More importantly, libcurl provides a C API that can be embedded into other applications, which wget does not offer. This library capability is the primary reason cURL has achieved its massive installed base — it is not just a command-line tool but a programmable platform used by thousands of applications across every industry.
What is the future of cURL?
cURL continues to evolve with the internet. Current development focuses on HTTP/3 support (using the QUIC transport protocol), improved security hardening (including memory-safe components written in Rust via the hyper backend), and new protocol support. Stenberg has outlined a long-term vision that includes better integration with modern development workflows, improved performance for high-throughput applications, and continued participation in internet standards development. The project’s transition to a more sustainable funding model — with corporate sponsors and Stenberg’s role at wolfSSL — suggests that cURL will continue to be actively maintained and developed for the foreseeable future. Given that the internet’s reliance on cURL only grows as more devices come online, Stenberg’s role as the steward of this critical infrastructure remains as important as ever.
