
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>White Hydrogen - The Game-Changing New Energy Form</h3><h4>13 May 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>Although still in its infancy with lots of uncertainty, white hydrogen has the potential to be a gamechanger for the clean hydrogen sector as an affordable, clean natural resource.<em>"</em></p><p>Minh Khoi, Rystad Energy</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='white-hydrogen' href='/Content/Downloads/ARP/ARP240513.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/664232b82a6ff0d4ec79f8fe_iStock-1260305510_705x414.jpg#239;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#349;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#349;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#349;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#349;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>At our April webinar, I struggled to answer a couple of the questions addressed to me, as I needed to conduct further research before responding. The first question was addressed in a recent research paper called <em>Ceramic Heat Dissipation Substrates </em>which you can find <a href="https://www.arpinvestments.com/insights/ceramic-heat-dissipation-substrates">here</a>. The second question was about white hydrogen which is addressed in this research 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#350;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#350;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#350;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#350;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The different ‘colours’ of hydrogen</h4><div>
<p>Let&rsquo;s begin by clarifying what hydrogen is. Hydrogen (symbol H in the periodic table) is the lightest and most abundant chemical element in the universe. It consists of only one proton and one electron and is highly reactive, meaning it is able to form, and has indeed formed, many compounds with other elements. Take for example water (H2O) which consists of hydrogen (H) and oxygen (O). Hydrogen is naturally a gas but can be converted to a liquid, allowing us to use it as a safe alternative to petrol or diesel. Hydrogen comes in many &lsquo;colours&rsquo;:</p>
</div>

<div>
<div>
<p><em>Grey hydrogen</em> (aka brown or black hydrogen) is produced through conventional energy sources (i.e. fossil fuels) or via a process called Steam Methane Reformation (SMR) which uses natural gas or methane. Grey hydrogen has, in recent years, accounted for most of the liquid hydrogen produced (62% in 2022) but is considered the least environmentally friendly form of liquid hydrogen, as all the CO2 produced in the process is released into the atmosphere.</p>

<p><em>Blue hydrogen</em> is produced via natural gas or coal gasification combined with carbon capture storage or other carbon capture technologies to reduce carbon emissions. It is more environmentally friendly than grey hydrogen as most of the CO2 produced is captured and stored, but it is far from perfect.</p>

<p><em>Green hydrogen</em> was, until recently, considered the most environmentally friendly form of liquid hydrogen. It is produced by deploying a technology called water electrolysis, where you separate the H from the O in water. By using electricity generated by a renewable energy source (typically wind or solar), no CO2 is produced. Although by far the cleanest (so far), green hydrogen accounts for less than 5% of all liquid hydrogen produced, and the reason is cost.</p>

<p><em>Pink hydrogen</em> is produced by deploying the same water electrolysis process as when producing green hydrogen, but nuclear energy is used instead of renewables. No CO2 is produced.</p>
</div>
</div>
</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#351;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#351;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#351;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#351;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Introducing white hydrogen</h4><p><em>White hydrogen</em> is the latest form of liquid hydrogen. It is as environmentally friendly as green hydrogen but varies from it in a couple of important aspects:</p>

<p>1.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;White hydrogen is naturally produced&nbsp;in the Earth&rsquo;s crust and can be found in large quantities in most parts of the world. It is estimated that, globally, there could be tens of billions of tonnes of white hydrogen.</p>

<p>2.&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;White hydrogen is&nbsp;much cheaper to produce than green hydrogen. It can be produced today at about $1 per kilogram, while the production cost of green hydrogen is almost $6 per kilogram at present.</p>

<p>Like green hydrogen, no CO2 is emitted in the process, hence why it is considered clean. Sometimes, white hydrogen is referred to as natural hydrogen. Occasionally, it is also called gold hydrogen or geologic hydrogen.</p>

<p>Until the 1970s, nobody knew white (natural) hydrogen existed. Scientists thought hydrogen would always combine with other elements to form hydrocarbons or other materials. Only in the early 21st century was the first major white hydrogen deposit discovered. &nbsp; &nbsp;</p>

<p>According to the United States Geological Survey (USGS), there may be tens of billions of tons of white hydrogen hidden beneath the Earth&rsquo;s surface, enough to provide clean energy for hundreds of years (source: New York Times). However, Geoffrey Ellis at USGS points out that there is still considerable uncertainty as to how much there is.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Major white hydrogen projects underway </strong><br />
<em>Source: </em><a href="https://www.rystadenergy.com/news/white-gold-rush-pursuit-natural-hydrogen"><em>rystadenergy.com</em></a></p>
' data-image='/Content/Images/664235a9c51ef063ac22babd_Picture1.png#352;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#352;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#352;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#352;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Where can you find white hydrogen?</h4><p>Very large deposits have been found in Bourakebougou in Mali, in the Yorke Peninsula in Australia, in the foothills of the Pyrenees in Spain, in the Lorraine basin in France and in various parts of the US (Exhibit 1) with other significant discoveries in Eastern Europe, Columbia, Oman, Iceland, Kazakhstan, South Korea and Japan. Mali is currently the only country in the world actively extracting white hydrogen. All the other countries mentioned are still looking into how best to extract it.</p>

<p>--image--</p>

<p>The fact that significant deposits have been found on most continents is a major positive, in my opinion. Consequently, it is less likely that an OPEC-like cartel will form over time &ndash; good, both for pricing and for global geopolitical stability.</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#353;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#353;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#353;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#353;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How competitive is white hydrogen, cost-wise?</h4><p>The advantageous cost comparison referred to above is based on the experience from Mali, but Mali is unique, geologically speaking. Other countries are not expected to deliver white hydrogen at $1 per kilogram for quite a few years, and such a price is considered necessary to compete with natural gas (source: HyTerra).</p>

<p>Spanish company Helios Arag&oacute;n has stated that it can produce natural gas from the vast underground layers in the foothills of the Pyrenees at a cost of $0.80 per kilogram. On its website, Helios Arag&oacute;n admits that it is still many years away from producing white hydrogen at that cost but, at the same time, estimates that, by 2060, the cost of producing white hydrogen should be as low as $0.55 per kilogram. Over the same time horizon, in the opinion of Helios Arag&oacute;n, the cost of green hydrogen is expected to drop to about $0.80 per kilogram. In other words, both green and white hydrogen are expected to become competitively priced vis-&agrave;-vis natural gas over time but white hydrogen more so than green hydrogen.</p>

<p>Having said that, Canadian producer, Hydroma, claims that it can extract white hydrogen at an estimated cost of $0.50 per kilogram <em>today </em>(source: Rystad Energy); i.e. commercialisation would probably not be that far away if price were the only factor (but it isn&rsquo;t).</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#354;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#354;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#354;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#354;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The pros and cons of white hydrogen</h4><p>One can build a pretty powerful set of arguments why white hydrogen is a game-changing material, and why it is likely to become a cornerstone in tomorrow&rsquo;s energy supply chain. Having said that, there are also some rather convincing arguments against, hence why I will list the pros and cons here.</p>

<p><strong>Key positives:</strong></p>

<p>-&nbsp;Earth holds vast supplies of white hydrogen which can relatively easily be extracted.</p>

<p>- No CO2 is emitted when producing it.</p>

<p>- Unlike fossil fuel deposits, which take millions of years to form, white hydrogen is continuously replenished.</p>

<p>- It is very cost-efficient vis-&agrave;-vis all other types of liquid hydrogen and is likely to become cost-efficient vis-&agrave;-vis natural gas within the next few decades, if it isn&rsquo;t already.</p>

<p><strong>Key negatives:</strong></p>

<p>- As white hydrogen is a natural, renewable energy source, in theory, it should be possible to extract it endlessly at a low cost. However, this is not the case in practice. Significant hurdles, mostly technological ones, remain.</p>

<p>- It isn&rsquo;t yet clear exactly how white hydrogen deposits form. Therefore, we do not yet know if we do any damage to the environment by extracting it.</p>

<p>- Not only are hydrogen molecules much smaller and lighter than those in methane, making them harder to contain, but they are also far more explosive than natural gas, raising safety concerns.</p>

<p>- If hydrogen seeps into the atmosphere, it can reduce the concentration of molecules that destroy greenhouse gases, counteracting its environmental benefits.</p>

<p>- The infrastructure required to handle the conversion from gas to liquid form is inadequate. In gas form, hydrogen takes up a lot of space and requires a temperature of -253&deg;C to be liquified, which could be prohibitively expensive. There is also a lack of pipelines and distribution systems for the handling of hydrogen.</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#355;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#355;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#355;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#355;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Caveat</h4><p>For the sake of transparency, I ought to stress that we have not (yet) started to invest in this opportunity, nor have we conducted any in-depth research on the topic. Having said that, I believe it is still, first and foremost, a private markets opportunity, with the opportunity set gradually moving from private markets to public markets over the next few years.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: EU&rsquo;s use of fossil fuels in 2023 &amp; the impact on emissions </strong><br />
<em>Source: Ember</em></p>
' data-image='/Content/Images/6642363f24ce2abfa488999c_Picture2.png#356;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#356;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#356;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#356;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Conclusion</h4><p>Although natural gas has been declared green by the EU, it is still a significant cause of atmospheric pollution (Exhibit 2). The only good news, I suppose, is that it emits fewer greenhouse gasses (GHG) than coal, i.e. the ongoing conversion from coal to gas should result in lower GHG emissions.</p>

<p>--image--</p>

<p>That said, I don&rsquo;t think we are that many years away from the EU classifying natural gas as damaging. That will most likely lead to an accelerated conversion to green energy forms. Certain countries are already big on wind and solar, but those two energy forms are not stable enough to form the base of a modern economy&rsquo;s energy supply until grid batteries become much more powerful. The most powerful batteries available today &ndash; those used in California &ndash; can only keep the economy running for a few hours.</p>

<p>For a long time, my view has been that, for many years to come, only one energy form &ndash; nuclear &ndash; is reliable enough to form that base, but white hydrogen has now entered the frame as a potential longer-term alternative/supplement to nuclear energy. I deliberately say &ldquo;longer term&rdquo;, as there are still far too many unanswered questions for white hydrogen to be rolled out over the near term.</p>

<p>The other aspect is that nobody wants to rely on a single source for all its energy needs. It is far too risky a strategy. Therefore, as we turn greener, I could easily see nuclear energy, wind, solar, green and white hydrogen operating side by side. And, given nuclear&rsquo;s low market share compared to that of wind and solar&rsquo;s, I would expect hydrogen (whether green or white) to take a bite of wind and solar&rsquo;s market share rather than nuclear&rsquo;s.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>13 May 2024</strong></p></div></div></div>