Programming code is the language of our computers. It allows developers to prompt computers, smartphones, and data centres to carry out specific actions. If we focus on sustainable digitalisation by writing code that ensures end-user devices, servers, and IT infrastructure consume less energy, software becomes a vital key to decarbonising our IT.
However, the precise definition of ‘software’ has changed significantly over the last few decades. When a programmer writes code, it no longer simply triggers actions on the device executing the lines of programme. When considering sustainable software, we must think in terms of ‘distributed systems’—that is, interconnected devices that share computing operations, stored data, and more between one another. To understand this better, we spoke with Teresa Zeck from the German Informatics Society (GI).
Teresa Zeck is the Project Coordinator for ECO:DIGIT, a collaborative initiative between the German Informatics Society (GI), the Oeko-Institut, and other partners including adesso SE, Siemens, and the Open Source Business Alliance. The project is funded by the Federal Ministry of Education and Research.
How do you measure the carbon footprint of software?
“We have developed a Life Cycle Assessment (LCA) methodology for software. The cornerstone of this was our desire to establish a link between software activity and environmental impact,” says Teresa, describing the ECO:DIGIT approach during our conversation. The ECO:DIGIT methodology therefore combines data from actual software usage with relevant environmental factors. However, one challenge is that distributed systems perform a vast array of different computing operations.
How does distributed software look in practice?
Let’s illustrate this with a specific example:
In 1989, Microsoft introduced the “Office” software, which almost everyone has worked with at some point.
If Teresa Zeck and her team had wanted to measure the ecological footprint of MS Office in the past, they would only have needed to measure the energy consumption during use and track the resources of the hardware being used. Through an allocation process, the researchers would then have had to determine what proportion of those resources the software actually utilised in practice.
In 2026, Microsoft Office exists only as a cloud application. Here, in addition to the hardware used to run the programme and its power consumption, they would also have to include the computing operations that Microsoft offloads to its data centres, known as Azure. This includes an allocation and the inclusion of the resources required to operate these data centres.
Furthermore, the researchers would have to track the volume of data transmitted by the software—and factor in the resources required for that transmission as well.
Teresa Zeck identifies the allocation of computing operations as a central challenge. These digital platforms aren’t dedicated solely to one service. Instead, they are shared across many different tasks, often for only a fraction of a second at a time. To calculate an accurate Life Cycle Assessment (LCA), “every link in the digital supply chain must be evaluated and correctly assigned.” Put simply: to get a realistic environmental picture, you must determine exactly what share of a computer or server is being utilised by a specific programme.
To achieve this, the ECO:DIGIT methodology tracks what it calls “basic digital resources.” Teresa Zeck defines these as computing operations, data transfers, RAM, and persistent storage. “We then map these resources to the underlying hardware components—such as end-user devices or network infrastructure.”
What began as a hurdle has now become the methodology’s standout feature. “The key is that we don’t just look at energy consumption and greenhouse gas equivalents,” Zeck explains. “We also account for ecotoxicity, electronic waste, the depletion of abiotic resources—such as metallic and mineral raw materials—and even water consumption.”
The rise of AI-based chatbots in recent years highlights just how complex a holistic assessment of modern software has become. While developers of large language models often point to the minimal energy consumption of a single query, a full life cycle assessment reveals a far more sobering reality. Furthermore, there is the undeniable cumulative effect: a low-energy action, when multiplied millions of times over, inevitably leads to a massive surge in total consumption.
Digital Twin for real-world measurements
Alongside the methodology, the ECO:DIGIT team has developed a testbed for both new and existing applications. Across four specific areas—Edge Computing, Cloud Platforms, mobile end-user devices, and mobile networks—ECO:DIGIT provides developers and software providers with a platform to evaluate the life cycle assessment of their programmes.
By using specific usage scenarios, the written code, and details of the target platforms, the researchers create a digital twin of the software. The testbed then provides forecasts for computing power, network load, RAM, and mass storage. This allows developers to test the environmental impact of their software not just on individual devices, but at scale—within cloud computing environments, for example.
As a result, projects like Carbonara, which provide a preliminary environmental assessment during the coding process, could be expanded to include cloud and edge computing scenarios. However, ECO:DIGIT does not yet cover all software deployment scenarios; the testbed is currently unable to analyse mobile end-user devices or mobile networks.
Complex systems with even more complex environmental consequences
This practical and holistic view of distributed software systems highlights a clear reality: reliably estimating the life cycle assessment of modern software is an exceptionally complex task. Current trends make this even more difficult. Beyond all the promises of “superintelligence,” AI-based carbon heavyweights like ChatGPT or Perplexity are, at their core, simply distributed software systems. However, such software relies massively on GPU power, as it must execute a vast number of computing operations simultaneously.
“What our methodology currently does not take into account is GPU evaluation. This was initially omitted, and generally, our research project does not cover every single component,” Teresa Zeck explains when asked about the measurability of AI systems. To address this, the team designed ECO:DIGIT from the ground up according to open-source standards.
The project coordinator hopes that “ECO:DIGIT will be further developed by the open-source community, and that the approaches will serve as a foundation for new tools after the project ends.”
Although the ECO:DIGIT project concludes in May 2026, the methodology answers a vital question: where exactly in our digital world is resource consumption highest? The more precisely we understand the causes behind the negative environmental footprint of digital systems, the better we can work on sustainable solutions.
Additionally, a new ISO standard was introduced in early March that summarises requirements and guidelines for sustainable software. ECO:DIGIT’s research has directly informed this standard. Companies can now use it as a framework during product development to minimise the environmental impact throughout their software’s life cycle.
