
<div class='article-page-content__container'>
<div class='article-page-content__container__left'><h3>Project Ignition - the Main Risk to the Uranium Bull Story</h3><h4>15 January 2024</h4><div class='category-icon'>Research</div><div class='article-page-content__container__left__summary'><p><em>"</em>In December 2022, after more than a decade of effort and frustration, scientists at the US National Ignition Facility announced that they had set a world record by producing a fusion reaction that released more energy than it consumed — a phenomenon known as ignition<em>"</em></p><p>Nature.com</p></div><h5>By Niels Clemen Jensen</h5><div class='article-page-content__container__left__links'><a download='project-ignition' href='/Content/Downloads/ARP/ARP240115.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/65a5620123138a1fc39bad99_iStock-1463916230_705x414.jpg#233;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#382;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#382;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#382;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#382;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Why another paper on fusion energy?</h4><p>As most of you will be aware, for years, I have been bullish on uranium. The first time I wrote about it was in March 2020 &ndash; see&nbsp;<a href="https://www.arpinvestments.com/insights/the-bull-case-on-uranium">here</a>. I struggled, and continue to struggle, to see many clouds on the horizon but, as I keep reminding myself, every coin has two sides.</p>

<p>In the case of uranium, as far as I can see, three incidents could do significant damage to the bull case:</p>

<p>1. Another accident similar to Chernobyl or Fukushima.</p>

<p>2. A surge in supplies.</p>

<p>3. The introduction of a new and superior technology. &nbsp;</p>

<p>The first incident is a tail risk which is exceedingly hard to quantify. It is just a risk we all have to live with, I suppose. I take a very pragmatic view as far as that risk is concerned. If we don&rsquo;t expand the nuclear capacity, we will be stuck with fossil fuels for so long that the world will probably go under anyway (and I am not joking).</p>

<p>The second incident is easier to embrace. The uranium price is now so high &ndash; over $100/lbs for the first time since 2007 vs. $24-25/lbs when I wrote the first uranium paper in March 2020 &ndash; that mining companies are incentivised to increase production. And the price is also high enough to incentivise new exploration projects to go ahead &ndash; something which hasn&rsquo;t been the case since early 2008.</p>

<p>&nbsp;</p>

<p>That is certainly something which could do material damage to the uranium price over the long term; however, in the short to medium term, the supply side won&rsquo;t be affected, as it takes at least 6-7 years from going ahead with such plans until the mined&nbsp;<em>and enriched</em>&nbsp;uranium can be fed into a nuclear reactor. In other words, for at least another six years, we know that the uranium market will be undersupplied.</p>

<p>Now to the third incident which seems to be a risk to the uranium price that is underestimated by many. At some point, another technology will take over. You shouldn&rsquo;t expect uranium-fed fission reactors to keep a monopoly on nuclear energy forever. One possibility is that thorium will replace or, at least, operate side-by-side with uranium. See my paper on thorium from July 2021&nbsp;<a href="https://www.arpinvestments.com/insights/thorium">here</a>. The Indians would love for that to happen, as they sit on the largest thorium reserves worldwide.</p>

<p>I am not convinced, though. We are still several years away from a commercial rollout of thorium-based reactors, and I believe (for reasons you will see in a moment) that another new, and much more powerful, technology is now so advanced that potential buyers will be reluctant to embrace thorium.</p>

<p>The new technology I am referring to is fusion energy which I have also written extensively about before (see for example&nbsp;<a href="https://www.arpinvestments.com/insights/the-biggest-opportunity-of-a-lifetime">here</a>). Fusion energy has been a dream amongst scientists for at least half a century. The joke is that fusion energy is 30 years away and will always be 30 years away. Not anymore, though, and that makes me conclude that fusion energy is by far the biggest long-term risk to the uranium bull story. Once the first commercial fusion reactor is up and running, I doubt another fission reactor will ever be built again.</p>

<p>Just to remind you &ndash; in a fusion reactor, it takes about 0.15 m3 (half a bathtub of water) plus the amount of lithium contained in one laptop battery to produce enough electricity per capita for the next 30 years. Even better, fusion energy is the cleanest energy ever produced, and the marginal cost of production is close to zero. Meltdowns&nbsp;<em>cannot&nbsp;</em>happen (there is nothing that can cause that to happen), and the waste coming from a fusion reactor is far less dangerous than the waste originating from a fission reactor.</p>

<p>Therefore, it is hard not to see&nbsp;<em>everybody&nbsp;</em>going down the fusion road, once the technology is rolled out. That said, existing fission reactors won&rsquo;t cease to operate from one day to the next &ndash; obviously not, but the order book on new fission reactors will most likely dry out very quickly. Therefore, demand for uranium will stop growing, and the market will most likely become oversupplied. The critical question is&nbsp;<strong><em>when is this likely to happen?</em></strong></p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 1: Recent ignitions at the US National Ignition Facility</strong><br />
<em>Sources: Lawrence Livermore National Laboratory, </em><a href="https://www.nature.com/articles/d41586-023-04045-8"><em>nature.com</em></a></p>
' data-image='/Content/Images/65a564c64304afb56bd20ba7_Picture2.png#383;slide-image;;' data-alt-text2= '<p><strong>Exhibit 2: The first year of ignition at NIF</strong><br />
<em>Source: Lawrence Livermore National Laboratory</em></p>
' data-image2= '/Content/Images/65a565137e8c7fe92c8c0b5c_Picture3.png#383;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#383;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#383;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>How far down the road are we today?</h4><p>On the 5th of December 2022, a milestone was reached. For the first time ever, a fusion reactor generated more energy (electricity) than was used to start the fusion process. &nbsp;&ldquo;Pure luck&rdquo;, the critics claimed, arguing that whilst in principle interesting, fusion energy will never be commercialised. The hurdles are simply too big, they said.</p>

<p>--image--</p>

<p>Despite all the scepticism, the successful test in December 2022 was repeated no less than three times in 2023. Even better, the gap between energy in and energy out improved significantly. At the December 2022 test run, 54% more energy was generated than the electricity used by the laser. The gap improved to nearly 90% at the most successful run in July 2023 (Exhibit 1).</p>

<p>Let me remind you how the fusion technology actually works &ndash; at least at the National Ignition Facility (NIF) in Livermore, California, where most US fusion research is conducted. 192 laser beams are fired at a frozen pellet of deuterium and tritium &ndash; both hydrogen isotopes which are housed in a diamond capsule suspended inside a gold cylinder.</p>

<p>The resulting implosion causes the isotopes to fuse, thereby creating helium and energy. In order to achieve ignition, the 192 beams must arrive at the target within 30 picoseconds of the prescribed arrival time. One picosecond is one trillionth of a second or 0.0000000000001 second. To achieve that is quite a marvel, engineering-wise.</p>

<p>At the successful ignition in December 2022, 2.05 megajoules of energy were beamed at the target, and that generated 3.15 megajoules of energy. The test was repeated in July 2023 with even more success. 3.88 megajoules of energy were generated at that test (Exhibit 2). &nbsp;As you can also see below, the scientists at NIF have conducted a further two successful tests in the second half of 2023, i.e. nobody can any longer claim that the success is down to luck. To put things into perspective, for the first time ever, scientists have mimicked the process inside the sun.</p>

<p>--image2--</p>

<p>So far so good, but I should point out that the laser approach deployed at NIF is fundamentally different from the tokamak approach deployed in most other fusion research centres around the world, including the biggest of them all &ndash; ITER in France. At this stage, it is hard to predict which of the two technologies that will ultimately prevail, but NIF has clearly taken a commanding lead. This means that <em>enormous </em>sums of money could have been wasted on the tokamak technology, but that is the name of the game, I suppose.</p>

<p>Should the laser technology prevail, in addition to having wasted billions of dollars, the Europeans and Asians would suddenly find themselves well behind the Americans in terms of developing a new, green and <em>very </em>safe technology, which could grant the Americans a massive competitive advantage in the years to come.</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#384;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#384;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#384;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#384;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>The next step</h4><p>More than 20 years have been invested to get NIF to this point. However, as NIF director Gordon Brunton has said (quoting Winston Churchill): <em>&ldquo;Now is not the end. It is not even the beginning of the end. But is, perhaps, the end of the beginning&rdquo;</em>. There is still a long way to go from proof of concept to commercialisation, though. To generate electricity in quantities that makes commercialisation feasible, you need a much more powerful laser than the one NIF currently has.</p>

<p>The good news is that the success at NIF has had the effect of catching policy makers&rsquo; attention. More money is being thrown after NIF now, and Capitol Hill has decided to establish a new research hub at the University of Rochester in upstate New York and another one at Colorado State University in Fort Collins. &nbsp;As far as those two new hubs are concerned, one of the most important objectives will be to build a more powerful laser. According to NIF, a more powerful laser would provide more margin for ignition, i.e. a higher probability of success.</p>

<p>Going back to Exhibit 2 for a moment, if you look at the progress from December 2022 to October 2023, you are entitled to wonder why the record-beating test run in July 2023 couldn&rsquo;t be surpassed in the two tests in October last year. The answer is simple. Now that the code has been broken, different laser techniques and different optics are being tested. I should also mention that, at the third ignition last October, even if the output was &lsquo;only&rsquo; 2.4 megajoules, nearly 450 <em>trillion </em>watts of power was generated at the peak.</p>

<p>Over the next year or two, the scientists will continue to make only modest changes. As they say, little changes can have a surprisingly big impact on the output, and now is time for those minor adjustments. Over the medium term, as a new and more powerful laser becomes available, that will also have to be tested.</p>

<p>As you can see, there is still plenty of testing to be done, and one shouldn&rsquo;t expect fusion energy to be added to the grid anytime soon. Management at NIF are appropriately vague when it comes to estimating when that is likely to happen. As they say, there is still going to be bumps on the road, but the early 2030s seems to be a good guesstimate.</p>
</div><div class='article-page-content__container__right__item' data-alt-text='<p><strong>Exhibit 3: Worldwide uranium production vs. reactor requirements (tonnes)</strong><br />
<em>Source: </em><a href="https://world-nuclear.org/information-library/nuclear-fuel-cycle/uranium-resources/uranium-markets.aspx"><em>World Nuclear Association</em></a></p>
' data-image='/Content/Images/65a565f11a5e42039ae44343_Picture4.png#385;slide-image;;' data-alt-text2= '' data-image2= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#385;slide-image2;;' data-alt-text3= '' data-image3= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#385;slide-image3;;' data-image4= '//img.vertouk.com/800x600/F7F7F7/90133B/F7F7F7/?type=mini&showres=false#385;slide-image4;;'> <h4 class='article-page-content__container__right__item__title'>Investment implications</h4><p>Worldwide, there are four sources of demand for uranium:</p>

<p>1. Demand from power stations.</p>

<p>2. Demand from research centres.</p>

<p>3. Military demand (for nuclear weapons).</p>

<p>4. Financial investor demand.</p>

<p>In terms of the overall picture, (2) and (3) are inconsequential, i.e. demand is largely defined by (1) and (4). In the previous bull market in the late 00s, (4) was also miniscule, but it has become a meaningful factor in recent years. &nbsp;Having said that, (1) is still the dominating factor.</p>

<p>According to the <a href="https://world-nuclear.org/information-library/nuclear-fuel-cycle/uranium-resources/uranium-markets.aspx">World Nuclear Association</a>, about 440 reactors with a combined capacity of about 390 GWe require approx. 62,500 tonnes of mined uranium each year to keep all reactors running 24/7. Many new reactors are scheduled to come into operation over the next few years, and we know that, for every GWe of added capacity, about 160 tonnes of additional mined uranium shall be required. That increases to 300-450 tonnes for the first load, as most nuclear power stations keep enough uranium in stock to be able to operate independently of the spot market for 1-2 years.</p>

<p>We also know that, in recent years, uranium mining worldwide has been insufficient to cover the 62,500 tonnes needed (Exhibit 3). As actual production has been well below the amount required by power stations (and that doesn&rsquo;t include <em>any </em>demand from (2), (3) and (4) above), we know that power stations have been forced to take from inventories to keep their reactors running.</p>

<p>We also know that North American power stations have been particularly guilty of running their inventories down, as they expected the uranium price to continue to fall. As this wave of re-stocking has not yet begun, we also know that the uranium price will almost certainly continue to rise for a while longer. We obviously don&rsquo;t know by how much but, as far as the price impact is concerned, the bias is (strongly) to the upside. I expect at least $150/lbs in this cycle.</p>

<p>--image--</p>

<p>And the price could quite possibly peak at much higher levels. About 60 nuclear reactors are currently under construction worldwide, and a further 110 are planned (see <a href="https://world-nuclear.org/information-library/current-and-future-generation/plans-for-new-reactors-worldwide.aspx">here</a>). That translates into about 18 GWe of added nuclear power capacity in 2024 alone and an additional 5-6,000 tonnes of uranium demand in a market that is already significantly undersupplied.</p>

<p>I should also point out that IEA has stated that an additional 20 GWe of nuclear energy shall be required globally <em>every year</em> for the world to stand any chance of meeting the Net Zero target by 2050. Therefore, you should expect many new nuclear projects to be announced over the next few years, and that alone is likely to affect existing power stations&rsquo; purchasing plans and cause them to increase inventories.</p>

<p>For all these reasons, I find it hard not to remain bullish on uranium despite the extraordinary run more recently. There will obviously be bumps on the road. Today, I shall not speculate what those bumps could be, but it would be rather na&iuml;ve to expect a trouble-free journey.</p>

<p>Before I wrap it up, one word of advice: when you invest in uranium, you can avoid mining execution risk altogether by investing in non-mining companies that give you direct exposure to the uranium price. We have a mix of mining and non-mining companies in our uranium portfolio, but this is an issue you should give some consideration.</p>

<p>Finally, a word of warning: even if the first fusion reactor won&rsquo;t go live until sometime in the early 2030s (at the earliest), I think fusion energy will start to affect the appetite for conventional nuclear before then. The more successful NIF and others are, the more media coverage the story will get, and the more likely it is that some projects will be deferred for a few years. Therefore, when you invest in uranium, build in an appropriate safety margin. As things stand right now, I think the road is clear until the late 2020s but not much longer than that.</p>

<p>&nbsp;</p>
</div><div><h4>By Niels Clemen Jensen</h4><p><strong>15 January 2024</strong></p></div></div></div>