
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Uranium or Nuclear Power? - Can you invest in nuclear energy without being (overly) exposed to the uranium price?</h3><h4>15 January 2025</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>Nuclear power is the cleanest, safest, and most reliable form of energy we have.<em>"</em></p><p>Bill Gates</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='uranium-or-nuclear-power' href='/Content/Downloads/ARP/ARP250115.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/61a756a2fd25c22f4fee0017_power-plant-3_705x414.jpg#253;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#287;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#287;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#287;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#287;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Preface</h4><p>The following is an adaption of an internal research paper on the nuclear energy industry. We have been bullish on uranium (U3O8) for years but grew increasingly frustrated last year, as the price on U3O8 struggled despite robust nuclear energy fundamentals. This research paper is our attempt to uncover the reason(s) behind the poor performance of U3O8 and how to respond to it.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Mining requirements of electricity sources and storage measured in kilograms of material per GWh of electricity generated.</strong><br />
<em>Source: Our World in Data</em></p>
' data-image='/Content/Images/6787fe97ac7990dae7773d73_6787f90c73cb123eca7fa1c8_Picture201.png#288;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#288;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#288;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#288;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Our investment thesis on nuclear energy</h4><p>Let&rsquo;s begin with our investment thesis on nuclear energy.</p>

<p>Without a meaningful contribution from nuclear energy, Net Zero will never happen, we believe. Wind and solar both suffer from intermittency problems, which make them unsuitable for the role many have assigned to them &ndash; to form the base of the world&rsquo;s future energy supplies. They can make a handsome contribution, but they cannot account for most of it &ndash; at least not until we have much more powerful grid batteries, and that will take many years. If the ultimate aim is to eliminate fossil fuels completely (and it is), nuclear energy is the only clean energy form which can make up the base. That is our investment thesis on nuclear energy in its simplest form.</p>

<p>--image--</p>

<p>Assuming you include GHG emissions from producing nuclear reactors, windmills and/or the solar panels used when generating electricity, it has long been known that nuclear is as clean as wind and cleaner than solar in terms of the total amount of GHG emitted. However, new data suggests that nuclear is even cleaner than wind when including the energy used to mine and store the raw materials in question (Exhibit 1).</p>

<p>A very rich pipeline of new reactors under construction makes up the essence of the bull story on nuclear energy. Worldwide, there are about 440 nuclear reactors up and running today. A further 60 are currently under construction, and another 110 will go into construction over the next two years. Most of those are in Asia. In China alone, there are plans for over 200 nuclear reactors over the next ten years &ndash; more than have been built in the rest of the world over the past 35 years.</p>

<p>Last time demand dramatically exceeded supply, the U3O8 price peaked at $148/lb (in May 2007). With more than 200 new reactors scheduled to come onstream in China alone and almost twice that many worldwide over the next ten years, I believe we&rsquo;ll see even higher prices on U3O8 in this cycle.</p>

<p>Having said that, the uranium story is more a supply story than a demand story. Not that demand is irrelevant or that it is not growing. It is indeed, but it is subject to long lead times and is therefore highly predictable. In the OECD, it typically takes at least eight years from the decision is made to build a new reactor, until the first electricity from that reactor can be added to the grid.</p>

<p>Supply, on the other hand, is far less predictable, and a relatively weak uranium commodity spot price more recently has forced us to take a closer look at the supply side of the equation.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 2: Price of U3O8, last 3 years</strong><br />
<em>Source: Numerco</em></p>
' data-image='/Content/Images/6787fe97ac7990dae7773d76_6787f9791ee7f8f833b9f1a9_Picture2.png#289;slide-image;;' data-alt-text2= '<p><strong>Exhibit 3: U3O8 prices &ndash; spot vs. long term</strong><br />
<em>Source: Cameco</em></p>
' data-image2= '/Content/Images/6787fe97ac7990dae7773d8b_6787fb43767ecbc4373aaf83_Picture3.png#289;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#289;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#289;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Recent performance of U3O8</h4><p>As these lines are written, U3O8 trades at $74.00/lb within a bid-ask spread of $73.00-$75.00/lb. Over the first couple of weeks of 2025, the spot price on U3O8 has recovered a bit, but the last 12 months have been a painful experience, generally speaking (Exhibit 2).</p>

<p>--image--</p>

<p>According to Uranium Insider (our main source on the industry), there have been numerous examples over the last few months where (supposedly retail-related) selling in uranium ETFs has caused unexplainable weakness in uranium mining stocks &ndash; even on days where fundamentals would suggest the market to be quite strong. The obvious question to ask is therefore: is the current weakness best explained by financial investors dropping out, or is there something more fundamental going on?</p>

<p>If the latter, I have concluded that it <em>must </em>be supply-related, as demand for nuclear fuel is rising steadily all over the world. The following therefore contains an analysis of the supply outlook &ndash; of conventionally mined uranium but also of various alternatives to that.</p>

<p>Now, before going any further, I need to explain an important dynamic re U3O8. You can trade U3O8 both in the spot market and the forward market. Most industry buyers (predominantly nuclear power stations) do virtually all their buying in the forward market, whereas the spot market is mostly for financial buyers. I should also point out that the spot market is typically quite illiquid.</p>

<p>If you look at Exhibit 3 below, it is obvious that, last year, spot and LT prices behaved very differently. As you can see, a substantial gap between the spot and the LT price opened up in 4Q23 but, as 2024 progressed, the spot premium vanished again and eventually turned into a discount. As you can also see, the LT price was far steadier and only dipped marginally (from $81.50/lb to $80.50/lb) towards the end of last year.</p>

<p>--image2--</p>

<p>The inevitable conclusion from this observation is that whilst richer than expected uranium supplies may have had some impact on U3O8 prices in 2024, industry buyers have not demonstrated any meaningful change in behaviour. Almost all the impact has been on the spot price which is set by financial investors.</p>

<p>This doesn&rsquo;t imply that no action should be taken, though. Whether industry buyers or financial buyers are deemed responsible for the relatively poor performance last year, I will argue below that the spot price may stay subdued for several more years; hence why it may be necessary to focus on other parts of the nuclear energy value chain.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 4: Projected change in demand &amp; supply of U3O8</strong><br />
<em>Note: Data as of 30/09/2024<br />
Source: Sprott</em></p>
' data-image='/Content/Images/6787fe97ac7990dae7773d91_6787fba1666376ba4bec2387_Picture4.png#290;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#290;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#290;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#290;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The outlook for demand and supply</h4><p>According to industry sources, whether Net Zero will ever be accomplished or not, demand for U3O8 is likely to significantly outstrip supply, at least through 2040. If disregarding the impact of Net Zero (which may, at least partially, be necessary with Trump at the helm for the next four years), the cumulative deficit of U3O8 over the next 15 years will still amount to at least 1 billion pounds. When factoring in worldwide Net Zero pledges, the cumulative deficit should rise to well over 2 billion pounds of U3O8 (Exhibit 4). However, as is also obvious, unless you believe Net Zero to go full steam ahead, a meaningful gap between supply and demand may not open up until the early 2030s.</p>

<p>--image--</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 5: Uranium production cost by country (US$/lb)</strong><br />
<em>Source: Bank of America Merrill Lynch</em></p>
' data-image='/Content/Images/6787fe97ac7990dae7773d8e_6787fc27666376ba4becacf0_Picture5.png#291;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#291;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#291;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#291;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Risks to the demand/supply outlook</h4><p>Given the large number of nuclear reactors under construction, it is a relatively safe bet when I project that, longer term, demand for U3O8 will rise significantly, thus driving the price up. That said, a number of dynamics may affect the delicate balance between demand and supply in the near term. Demand is relatively easy to calculate, as we know precisely how many reactors are up and running at present, and how many will be added over the next few years, either because they come back from maintenance or because they are newly built.</p>

<p>Supply is a great deal more difficult to deal with. Various accidents happen regularly in uranium mines all over the world which may affect short-term supplies. Those types of disruptions are typically handled by taking from inventory and are not discussed below. However, various other dynamics may have a longer-lasting impact on global supplies and will be discussed.</p>

<p>One story that has gotten a lot of attention in recent months is the story about seawater &ndash; the fact that it contains a certain amount of uranium, and that this uranium can be extracted more inexpensively than it is possible to do when mining U3O8 &nbsp;conventionally. That said, uranium from seawater is far from the only supply risk to worry about.</p>

<p><strong>Supply risk #1: &nbsp; Is it possible to extract uranium from water? &nbsp;Yes but...</strong></p>

<p>The oceans are estimated to possess 4.5&thinsp;billion tonnes of uranium in a concentration of 3 microgrammes per litre. An adsorbent must be used to extract the uranium from the water; however, one kilogramme of adsorbent, after one month of submersion, will only yield about 2&thinsp;grammes of uranium when using the technology currently available. The material may be used six times before it is fatigued, not only making this process unscalable but also uneconomical unless (until) the prevailing technology is improved.</p>

<p>That said, US drinking water contains about 30 microgrammes of uranium per litre, i.e., it contains ten times more uranium than seawater, and it doesn&rsquo;t contain nearly as many other minerals that you would need to separate before using the uranium.</p>

<p>Whether seawater or drinking water is used, it is still very early days, though, and the current approach is not scalable, taking today&rsquo;s industrial processes into account. Someone would need to invent a clever mechanism which adsorbs uranium but not the other elements in water. One day, when that is invented, it might become feasible, but we are still many years away.</p>

<p>On the other hand, extracting uranium from water, if it ever becomes feasible, would turn nuclear energy into a truly renewable energy form which could change many people&rsquo;s attitude towards it and thus accelerate the growth of the industry. One would just have to be exposed to different parts of the value chain, should that happen.</p>

<p><strong>Supply risk #2: &nbsp; Could other countries be attracted to uranium mining? &nbsp;Yes but...</strong></p>

<p>For many years, the U3O8 price was deemed too low to attract much interest from countries not already mining it. With a price hovering between $25 and $50/lb, and with an incentive price to add new mining capacity of at least $60/lb in most countries (the incentive price is estimated to be 20-30% higher than the cost of producing it), essentially nothing happened. With a spot price in the low-mid $70s, that has all changed.</p>

<p>--image--</p>

<p>Let me share with you the most interesting example, Saudi Arabia, which is not even depicted in Exhibit 5. Saudi Arabia plans to exploit its &ldquo;huge uranium reserves&rdquo; (their words, not mine). Although the country has never provided any official figures, the Guardian newspaper has gained access to some leaked, internal documents which put the Kingdom&rsquo;s uranium deposits at an estimated 90,000 mega tonnes &ndash; about 1.4% of global reserves.</p>

<p>Those numbers suggest to me that Saudi Arabia will never become the major player in uranium that it is in oil. Furthermore, if it takes at least 7-8 years from planning to feeding the reactors with the first enriched uranium, we do not have to worry about Saudi supplies for quite a while, and the same is the case as far as other countries with sizeable reserves are concerned (ex. Australia &ndash; see later).</p>

<p><strong>Supply risk #3: &nbsp; Is it possible to recycle already spent U3O8? &nbsp;Yes but...</strong></p>

<p>The technology to recycle spent uranium was developed by the Americans back in the 1970s, but they barred it shortly afterwards for safety reasons (they said). Other countries did not, though, and recycling spent uranium is standard practice in France, the UK, Japan, Russia and India. In France, no less than 96% of the reusable material in spent fuel is recovered and recycled (see <a href="https://www.iaea.org/newscenter/news/frances-efficiency-in-the-nuclear-fuel-cycle-what-can-oui-learn">here</a>).</p>

<p>If more countries begin to follow this practice, demand for U3O8 will obviously be affected. Having said that, when researching the topic, I discovered that recycling spent uranium is <em>very </em>expensive, raising the price on U3O8 to about $150/lb. On the other hand, if fuel costs only make up 7-8% of total operating costs in nuclear power stations, a price hike of that magnitude is hardly meaningful when compared to the advantages.</p>

<p>No, I think there is a different, and altogether more cynical, reason why recycling isn&rsquo;t standard practice everywhere. Enriched uranium and plutonium are bi-products of the fission process, and both are needed in the weapons industry. If recycling U3O8 means starving the weapons industry of enriched uranium and plutonium to make nuclear weapons, who do you think the government will listen to when deciding whether to allow recycling or not?</p>

<p><strong>Supply risk #4: &nbsp; Could thorium take a reasonable share of the market? Definitely yes. </strong></p>

<p>In a research paper dated 18/07/2021 which you can find <a href="https://www.arpinvestments.com/insights/thorium">here</a>, I concluded that <em>&ldquo;investing in thorium is premature, that investing in uranium still makes sense for at least another 5-7 years, even if certain countries begin to switch to thorium-fuelled reactors, and that renewable energy forms will find their natural place next to nuclear energy in a fossil fuel-free world.&rdquo;</em></p>

<p>That was 3&frac12; years ago. Fast forward to January 2025, and we know a great deal more than we did in July 2021. Most importantly, we know that the Chinese, later this year, will commence the construction of the world&rsquo;s first thorium reactor in the Gobi desert. We also know that thorium reactors only use a fraction of the water used in uranium reactors, which is a major plus in drier climates, and we know that global supplies of thorium are <em>much </em>bigger than global supplies of uranium. Take for example China. It is estimated that China has sufficient thorium reserves to generate 100% of the electricity needed for 20,000 years if all rectors in the country were fuelled with thorium!</p>

<p>Thorium is fertile but not fissile on its own, i.e., a modest amount of enriched uranium shall still be required to start the fission process. One could therefore argue that thorium reactors are not <em>that </em>different from uranium reactors. In the July 2021 paper, I discussed various advantages and disadvantages of thorium vis-&agrave;-vis uranium and shall not go into any detail today. Suffice to say that I expect the two technologies to develop side by side, at least until the fusion technology enters the frame (see next).</p>

<p><strong>Supply risk #5: &nbsp; Should we take fusion energy seriously? Not until the mid-2030s. </strong></p>

<p>Commercialisation of fusion energy will be the ultimate game changer, but a commercial rollout is still at least ten years away. The most promising fusion project is conducted at the National Ignition Facility (NIF) at Lawrence Livermore Center in California. The management there have said that they expect to deliver the first fusion power to the grid no later than 2035.</p>

<p>What is unique about NIF is that it has, as the first test centre worldwide, been able to cross the critical line &ndash; more energy out than in. The line was first crossed in late 2022 and similarly successful results have been achieved in four subsequent tests. In the last test in late 2024, energy out was more than 2x energy in &ndash; a record high. If you wish to learn more about the NIF project, click <a href="https://www.youtube.com/watch?v=l5azMXvBfaw">here</a>.</p>

<p>Once fusion power is up and running, the marginal cost of electricity will be close to zero, and conventional power plants &ndash; both nuclear and non-nuclear &ndash; will probably be phased out, such are the advantages of fusion energy. A fusion reactor only needs water (sea water will do) and lithium to start the fusion process. Even better, a fusion reactor <em>cannot </em>melt down. Nor is there a meaningful amount of nuclear waste left over. For those reasons, I would expect most anti-nuclear supporters to soften their stance once it is introduced. That said, I do not expect fusion energy to have a significant impact on U3O8 prices until the early 2030s.</p>

<p>I should also point out that even after fusion energy has been commercially rolled out, already up-and-running fission reactors won&rsquo;t stop operating from one day to the next. That will make absolutely no economic sense. You should only expect fission reactors to be phased out once they reach the end of their working life which is, on average, more than 50 years after installation. In other words, demand for U3O8 will slow down, but there will still be plenty of it for many years to come.</p>

<p><strong>Summing up the above-mentioned risk factors</strong></p>

<p>Of all the risk factors listed above, the one most easily addressed is probably the first, i.e., the risk of conventionally mined uranium being replaced by uranium from other sources, e.g. water, and how that will affect supply. As mentioned earlier, the cost of fuel in a conventional U3O8 reactor is only 7-8% of total operating costs, meaning that the impact on the electricity price from halving the fuel cost will be minimal. That simple fact doesn&rsquo;t completely eliminate this concern, but it does significantly reduce it.</p>

<p>In terms of added supply from countries not currently being major suppliers, the only country that seems capable of seriously upsetting the delicate demand/supply balance is Australia which holds massive supplies; however, various Australian governments have repeatedly said that keeping the fragile Australian environment intact is more important than becoming a global powerhouse in uranium mining. A change of mindset from there could have a meaningful impact on the price, though.</p>

<p>Recycling already spent uranium is not an issue that can keep me awake at night, and there are two reasons for that:</p>

<p>(i) As already mentioned, as long as certain countries produce nuclear weapons, recycling will be limited.</p>

<p>(ii) Even if all countries were to commit to recycling, the impact on total demand would in fact be quite modest, the reason being that not all nuclear waste can be recycled.</p>

<p>As far as thorium is concerned, I consider it to be a fact rather than a risk. It is already here, and the opening of the first commercial thorium reactor is already in the cards. Therefore, it is probably safe to assume that it has already been discounted into the U3O8 price.</p>

<p>The appetite for going with thorium is by far the biggest in India &ndash; hardly a surprise given that India holds the biggest thorium reserves worldwide. Chinese leaders have repeatedly said that thorium is a natural supplement to uranium in drier areas, but it is not going to replace uranium.</p>

<p>The final risk factor mentioned above &ndash; the commercial rollout of fusion energy &ndash; is definitely the biggest risk factor in the long run, but that has been the case for almost 100 years now. That is how long it has taken the industry to get to this point. NIF&rsquo;s promise to deliver electricity to the grid by 2035 should therefore be taken with more than a small dose of scepticism.</p>

<p>&nbsp;</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#292;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#292;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#292;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#292;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The nuclear energy value chain</h4><p>Many investors assume that the only scalable way to invest in nuclear energy is by investing in uranium mining companies. While correct that uranium mining companies appear to be the obvious choice, as U3O8 is <em>by far</em> the most common type of fuel used in the industry, thus integral to the growth story, it is not correct that there is nothing else to invest in. In no particular order, the nuclear energy value chain consists of:</p>

<p>- uranium mining companies;</p>

<p>- thorium mining companies;</p>

<p>- conversion &amp; enrichment companies;</p>

<p>- uranium brokers;</p>

<p>- nuclear reactor construction companies;</p>

<p>- electric utilities specialising in operating nuclear power stations;</p>

<p>- companies specialising in the treatment, storage and disposal of spent fuel; and</p>

<p>- radioactive waste management companies.</p>

<p>If the purpose is to reduce our exposure to the U3O8 spot price, investing in mining companies only make sense if they sell their output in the forward market, and not everybody does. Likewise, investing in uranium brokers (who act as middlemen between mines and licensed buyers) makes little sense, reason being that brokers are typically valued on the basis of the value of their uranium inventory, and the spot price is used to value that.</p>

<p>Furthermore, as almost all thorium-related activities have been limited to government-sponsored entities in India and China so far, and as the electric utility industry is already trading at obscene earnings multiples after an outstanding year last year performance-wise, only the industries below present attractive investment opportunities at present:</p>

<p>I. conversion &amp; enrichment companies;</p>

<p>II. nuclear reactor construction companies;</p>

<p>III. companies specialising in the treatment, storage and disposal of spent fuel; and</p>

<p>IV. radioactive waste management companies.</p>

<p>Conversion and enrichment of the mined uranium is required before the uranium can be used as fuel in a reactor, and Russia sits on 40% of the global enrichment market. The enrichment industry is one of the most attractive industries to invest in, I believe, reason being that the Russians recently introduced a temporary ban on exports of enriched uranium to the US.</p>

<p>Shortly after the Russians announced the temporary ban, the US Department of Energy (DoE) announced that it had granted an award to six companies engaged in enrichment research with an aggregate value of US$3.4 billion, which is a huge amount of money in this industry. The Americans are keen to reduce its reliance on Russia, and I expect DoE to fast-track this project.</p>

<p>As far as nuclear reactor construction companies are concerned, right now, (nearly) everybody&rsquo;s attention seems to be on SMRs. This is a relatively new industry, dominated by an eclectic mix of industry giants and up-and-coming players. So far, I have been reluctant to invest in it, as the key players have all had a fabulous ride already.</p>

<p>That said, somebody told me to switch my attention to South Korea. Construction companies in that country have a great reputation, and P/E values are not (yet) absurd. I like the South Korean angle, and there are three reasons for that:</p>

<p>1. An awful lot of nuclear power stations will be built over the next decade but, before a single pound of U3O8 can be fed into any of those reactors, tens of billions of dollars will have to be spent on reactor construction.</p>

<p>2. South Korean companies have a reputation around the world for being the best to deliver nuclear power stations on time and within budget. That should secure them a reasonable share of that business. &nbsp;</p>

<p>3. Both US and South Korean authorities appear keen to establish a framework for cooperation when it comes to rolling out SMRs. That should also benefit the industry in South Korea.</p>

<p>The two last opportunities listed above &ndash; companies specialising in the treatment, storage and disposal of spent fuel (III) and/or companies that specialise in radioactive waste management (IV) &ndash; are admittedly areas I don&rsquo;t know a great deal about yet. Further research shall be conducted before I feel ready to talk about those opportunities.</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#293;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#293;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#293;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#293;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Final few words</h4><p>With this paper, I hope to have made it clear that, while we haven&rsquo;t cooled on the nuclear energy opportunity, concerns about the near-term outlook for the U3O8 price, and particularly the U3O8 spot price, is causing us to seek exposure to other parts of the nuclear value chain.</p>

<p>Having said that,<em> and this is important</em>, the portfolio swaps we make are all 1:1. Under no circumstances do we want to reduce the overall exposure to nuclear energy. We may be reducing our exposure to U3O8 but not to nuclear energy. This is still our highest conviction investment case.</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>15 January 2025</strong></p></div></div></div>