
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Ever Heard of EROI? - Why wind & solar may not be the best energy forms to fuel the era of electrification</h3><h4>17 February 2025</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>So long as oil is used as a source of energy, when the energy cost of recovering a barrel of oil becomes greater than the energy content of the oil, production will cease no matter what the monetary price may be.<em>"</em></p><p>M. King Hubbert</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='ever-heard-of-eroi' href='/Content/Downloads/ARP/ARP250217.pdf'><i class='fa-solid fa-arrow-down-to-line'></i> Article PDF Download</a>
            <button onclick='shareArticle()' value='share'><i class='fa-solid fa-share-alt'></i> Share Article</button><a href='/megatrends'><i class='fa-solid fa-eye'></i> View Megatrends</a></div></div>
<div class='article-page-content__container__right'><div class='article-page-content__container__right__image'><img src='/Content/Images/67b32fba0dfa843b5cfae07c_iStock-1388213275_705x414.jpg#254;article-main-image;705;414' /></div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#279;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#279;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#279;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#279;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>There is a link between this paper and our last research paper &ndash; Uranium or Nuclear Power? &ndash; which was published on the 15th of January and which you can find <a href="https://www.arpinvestments.com/insights/uranium-or-nuclear-power">here</a>. This paper is not an outright continuation of the previous paper, i.e., the two can, in principle, be read independently of each other; however, nuclear energy plays a pivotal role in both of them, i.e., the knowledge acquired from reading the earlier paper may come quite handy, as you work your way through this paper.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#280;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#280;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#280;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#280;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What is EROI?</h4><p>You may not be familiar with the concept of EROI, so allow me to spend a minute to explain what it is about. EROI stands for Energy Return On Investment and is a fundamental, thermodynamic metric that is used to measure the efficiency of different energy forms &ndash; energy out vs. energy in, so to speak, or:</p>

<p><strong>EROI = Eout / Ein</strong></p>

<p>Energy efficiency is relatively simple to understand. In the oil industry EROI equals the energy value of the oil extracted divided by the energy value (cost) spent extracting it. Or take an example, borrowed with thanks from Goehring &amp; Rozencwaig&rsquo;s (G&amp;R&rsquo;s) most recent quarterly letter: In 1958, the era of flying across the Atlantic began when airlines introduced the Boeing 707 between London and New York. Within a few years, almost everybody chose flying over sailing when going from Europe to North America, and the reason was straightforward. Higher energy efficiency (EROI) when flying made air travel both faster and cheaper.</p>

<p>18 years later, when the Concorde was introduced, it became possible to cross the Atlantic in about three hours, and many expected it to grab a much bigger slice of the market than it ever did. Why didn&rsquo;t it? Because poor energy efficiency made it too expensive for 99% of all travellers.</p>

<p>The concept of energy efficiency has been formulised, allowing us to compare different energy forms &ndash; everything from fossil fuels to biomass energy can be measured and compared this way, and that is precisely what EROI allows us to do.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#281;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#281;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#281;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#281;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Various issues to do with EROI</h4><p>Before going any further, I should stress that the EROI varies over time, as the abundance of the energy source in question may change. It is also subject to geography, as its abundance will vary from location to location. The EROIs of wind and solar are particularly sensitive to the choice of location. Technological advances may also affect the EROI.</p>

<p>I should also point out that the lower EROI is, the less economical the energy form in question is. An EROI of 7:1 is considered the breakeven needed for it to make economic sense to use. Many political leaders will argue that the cost of energy cannot stand alone. If the consequence is significant climate change, we <em>must </em>be prepared to accept that the energy forms we are going to use are more expensive (they argue). I have some sympathy for that argument, and that is probably also why more recent EROI models include the cost of CO2 emissions, whereas earlier EROI models did not.</p>

<p>The challenge facing our political leadership is that there is a popular swing away from environmental consciousness at present. We saw it in Europe last June when the elections for the European parliament took place, and we saw it again last November, when Trump was elected to take control of the White House. Several recent opinion polls across Europe state more or less the same &ndash; that enough is enough. Many Europeans no longer want the green transition to continue, if it means declining living standards.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: EROI of various energy forms</strong><br />
<em>Note: Published in 2014<br />
Source: </em><a href="https://www.sciencedirect.com/science/article/pii/S0301421513003856"><em>sciencedirect.com</em></a></p>
' data-image='/Content/Images/67b331370a0ac0478e06ec7c_Picture1.png#282;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#282;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#282;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#282;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Energy forms and their EROIs</h4><p>For the reasons mentioned earlier, different sources quote different EROIs on various energy forms. Take for example hydro energy. A hydroelectric power station in, say, Canada may benefit from a much higher EROI than a similar hydroelectric power station in for example Finland, as the cost of generating the electricity may be lower in Canada. That could result in vastly different EROIs on hydroelectric power from one country to the next.</p>

<p>Oil provides another example. In the heyday of oil exploration when there was plenty of it, the EROI on oil is estimated to have averaged about 100:1. Fast forward to present times, when most of the easy-to-get-to oil has been found. Consequently, the EROI on oil has plummeted. As you can see in Exhibit 1 below, these days, the average EROI on oil and gas is about 20:1. For your information, oil and gas EROIs are often aggregated, as those two energy forms are typically extracted from the same wells, i.e., their production costs are combined.</p>

<p>--image--</p>

<p>I am not sure why nuclear energy and hydroelectric power were excluded from Exhibit 1, as they are both mentioned elsewhere in the paper. Hydro-electric power actually comes out with the highest EROI of them all, 84:1, whilst nuclear energy averages only 14:1.</p>

<p>The paper was written in 2013, and that was only a couple of years after Fukushima, i.e., the nuclear energy industry was in deep distress and production costs out of control. As you will see later, the EROI on nuclear energy is <em>much </em>higher today, some 11 years later.</p>

<p>It is also worth noting how high the EROI is on coal, which leaves policy makers (outside China) in a bit of a dilemma. In terms of CO2 emissions, as we all know, coal is quite damaging; however, as you can see in Exhibit 1, it is one of the most efficient energy forms available.</p>

<p>Why outside China? China has hundreds of new coal-fired power stations under construction despite constantly claiming to be very green. Sometimes it pays not to be a democracy.</p>

<p>In general, it is fair to say that, based on the numbers in the <a href="https://www.sciencedirect.com/science/article/pii/S0301421513003856">paper from Science Direct</a>, most renewable energy forms have proven far less energy-efficient than the energy forms we have used since the early days of the industrial revolution, fossil fuels. The ultimate implication of that, should we go all-in for renewable, is declining living standards. More on that later.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: EROI of various energy forms</strong><br />
<em>Notes: PV stands for photovoltaic solar energy, CCGT for Combined Cycle Gas Turbine.Published in 2024.<br />
Source: </em><a href="https://www.refletsdelaphysique.fr/articles/refdp/pdf/2024/03/refdp2024s24.pdf"><em>refletsdelaphysique.fr</em></a></p>
' data-image='/Content/Images/67b331a6424e3fed4ce32b0d_Picture2.png#283;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#283;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#283;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#283;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What a difference ten years make</h4><p>Let&rsquo;s fast-forward to 2024. Gerard Bonhomme and Jacques Treiner published (in Reflets de la Physique) what I believe is the most recent, comprehensive EROI study. You can find the paper <a href="https://www.refletsdelaphysique.fr/articles/refdp/pdf/2024/03/refdp2024s24.pdf">here</a>. Before sharing the results with you, I need to explain the meaning of the two terms &ldquo;buffered&rdquo; and &ldquo;unbuffered&rdquo;, the understanding of which is critical, when you read Exhibit 2 below.</p>

<p>Unbuffered EROI does not factor in any additional energy needs from for example storage, whereas buffered EROI includes the cost of the supporting infrastructure, e.g. storage and backup systems. For dispatchable energy sources like fossil fuels, the buffered and unbuffered EROIs are identical. For intermittent sources like wind and solar, additional costs, e.g. storage costs, make the unbuffered EROI meaningfully higher than the buffered EROI. Important to stress, in terms of the actual cost to society, it is the buffered EROI that matters.</p>

<p>--image--</p>

<p>In the case of wind, the enormous impact on the EROI of the need to smooth and balance demand with the electricity output makes it uneconomical even if, at first glance, the EROI looks attractive.</p>

<p>In the case of nuclear energy, various costs are holding back the EROI. The problem in the nuclear industry is that most reactors are quite dated. As far as the limited number of new reactors are concerned, the EROI is about &nbsp;100:1 and, as you will see later, I have reasons to believe that the EROI on nuclear energy will soon rise to 180:1 but more on that later.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#284;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#284;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#284;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#284;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>What does it all mean?</h4><p>The EROIs above were an eyeopener to me. If we rely on renewables to deliver all the power we need, we will be forced to take on projects that make little economic sense, and that will cause living standards to decline.</p>

<p>Why? Because relying on energy forms with EROIs below 7:1 means that it will cost more to extract it than the value we get out of it. Society will invest more in those energy forms than what will eventually come back, i.e., society as a whole gets poorer.</p>

<p>If, on the other hand, we follow Donald Trump&rsquo;s advice and continue to use fossil fuels as if we have never heard about climate change, the risk is that we will soon pass the point of no return. Make your choice!</p>

<p>Some (myself included) have argued that there is only one energy form which is available in sufficient quantities to supply the electricity needed without destroying the climate &ndash; nuclear energy. But how are we going to react, if we suddenly have another Chernobyl on our doorstep? I certainly hope it won&rsquo;t happen, but something ugly akin to Chernobyl or Fukushima could happen anytime.</p>

<p>In Denmark, we have a journalist called Anders Lund Madsen. I wish everybody could watch his programmes but, unfortunately, they are all in Danish. A while ago, he did a very watchable programme on nuclear energy, where he raised the uncomfortable question: <em>Is the risk of another Chernobyl the risk we have to live with to make sure the world doesn&rsquo;t go down in flames?</em></p>

<p>I have come to the conclusion that the answer to that question is affirmative. If we allow the Green Brigade to take full control of the agenda, the gap between rich and poor will continue to widen. That is the simple consequence, if we allow renewable energy forms to dominate. If, on the other hand, we close our eyes and continue to use fossil fuels, the world as we know it today might not be there for our grandchildren and their children.</p>

<p>In that context, I note that sea water levels along the eastern seaboard of the United States are projected to rise up to six feet by 2100. Therefore, it is a risk I would be prepared to live with, in particular because the prevailing reactor design, the design that has been used in the last 30 years, have not suffered a single accident. Even better, as you will see in a moment, a new, nuclear design &ndash; SMR &ndash; has emerged, and that has reduced the risk of another Chernobyl to nil.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#285;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#285;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#285;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#285;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>A brief note on the SMR technology</h4><p>Today, almost all nuclear reactors are high-pressure, water-based reactors. As you probably noticed when looking at Exhibit 2, the nuclear industry-average EROI is about 75:1; however, according to G&amp;R, the newest designs in the (conventional) nuclear reactor industry come close to 100:1.</p>

<p>So far, so good, but conventional nuclear reactors require operating pressures of over 2,000 psi to prevent the water from boiling at core temperatures of about 600&deg;C. That necessi&not;tates massive amounts of steel and concrete when constructing the reactor &ndash; an estimated 60-70% of the total energy invested &ndash; which obviously reduces the EROI.</p>

<p>Molten-salt SMRs (Small Modular Reactors) deal with this problem. As molten salt boils at 1,400&deg;C, which is well above the reactor&rsquo;s core temperature of about 600&deg;C, SMRs can operate at atmospheric pressure. The much lower pressure reduces the need for steel and concrete and also the need for expensive safety systems.</p>

<p>Furthermore, because the fission process happens at atmospheric pressure, the risk of a melt-down has been eliminated. According to G&amp;R&rsquo;s estimate, SMRs require 80% less energy to build than traditional reactors which will boost the EROI from 100:1 to 180:1 &ndash; the highest EROI known to mankind today.</p>

<p>Therefore, SMRs are the way forward. They are assembled mostly by advanced robotics in a factory and are subsequently shipped to the installation site, i.e., the risk of human error in the construction process has been pretty much eliminated. Because they are modular, the electricity output can be reduced when the need for power is lower. With today&rsquo;s technology, that is not an option. To restart a conventional, nuclear reactor which has been switched off costs hundreds of millions of dollars.</p>

<p>Also, SMRs can be positioned under-water to further enhance the safety. And, finally, an SMR power station takes up <em>much </em>less space than a conventional nuclear power station, allowing de-commissioned coal-fired power stations in the suburbs to be converted to SMR power stations. This will further improve the EROI, as the cost of transporting the electricity can be greatly reduced. Instead of generating the electricity 100 miles away from big urban centres, it can now take place in the suburbs.</p>

<p>For all those reasons, I tend to say &ldquo;yes&rdquo; when Anders Lund Madsen asks the rhetorical question: <em>&ldquo;Should we learn to live with the risk?&rdquo;</em></p>
</div><div class='article-page-content__container__right__item' data-alt-text='' data-image='//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#286;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#286;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#286;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#286;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>With this paper, I am not suggesting the penny will suddenly drop, leading our political leaders to conclude that renewable energy forms do not offer the solution we so desperately look for. We are (sort of) pregnant already. Having said that, as far as I see it, four boxes must be ticked when we choose which energy forms to rely on:</p>

<p>1. The energy forms we go with must be available in abundance.</p>

<p>2. The chosen energy forms cannot be damaging to either health or the environment.</p>

<p>3. The energy mix must be well diversified; we shouldn&rsquo;t allow a situation to arise where we depend on only one or two energy forms.</p>

<p>4. The energy forms we select must make sense economically.</p>

<p>The reality is that few (if any) energy forms tick all four boxes unconditionally. The prevailing energy form since the early days of the industrial revolution, fossil fuels, certainly doesn&rsquo;t tick #2 and, increasingly, not #1 either. Renewables, which (nearly) everybody raves about, don&rsquo;t tick #4, which I hope to have made clear with this paper, and #4 is critically important.</p>

<p>So, what&rsquo;s left? We don&rsquo;t all live in a country where hydroelectric power is the obvious choice. In reality, if we are serious about phasing out fossil fuels (but I do wonder, from time to time, how serious we really are), there is only one option left and that is nuclear energy, particularly SMR nuclear, where the risks have been dramatically reduced and the EROI much improved.</p>

<p>That said, we shouldn&rsquo;t allow ourselves to end up in a situation, where 100% of our energy needs come from nuclear &ndash; that is an unacceptable risk to take, and that is where renewables come in. &nbsp; &nbsp; &nbsp;</p>

<p>Even if the buffered EROI on most renewable energy forms is less than 7:1, I would argue it is a price worth paying, so long as you combine renewables with one or two other energy forms where the EROI is far higher, so that the blended EROI for society is easily higher than 7:1.</p>

<p>Therefore, going forward, your energy portfolio should, in my opinion, be very overweight SMR stocks and other plays on the nuclear theme such as uranium miners. Renewables, on the other hand, should weigh less, still overweight but only modestly so.</p>

<p>Why overweigh them at all if they don&rsquo;t make any economic sense? For the reason I gave you earlier &ndash; the fact that we are already pregnant. The political leadership has invested so much political capital in renewables that they are <em>very </em>unlikely to back out. Even Trump, who is well known for his tirades against renewables, particularly wind, is well aware that a substantial proportion of his supporter base has landed jobs because of the green transition. For that reason, I expect Trump to continue his tirades but to do little more than that.</p>

<p>One final point before I finish. Having just read this paper, you may think EROI is the answer to everything, but an EROI analysis <em>cannot </em>stand alone. Other aspects must be considered as well. What is the environmental impact of the energy form in question? What is the impact on health? Are there other risks that must be taken in consideration? Economic criteria <em>cannot </em>stand alone, as that could lead to suboptimal results.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>17 February 2025</strong></p></div></div></div>