[Question]
  [
# Input
This task takes no input.
# Output
Your code should compute and print (or return)  
\$\pi^y\$ for all \$y = \frac11, \frac12, \frac13, \frac14, \frac15, \frac16, \frac17, \frac18, \frac19, \frac1{10}, \frac1{11}, \frac1{12}\$. The first 20 digits of the output (truncated and without any rounding) should be correct in each case. 
Here are the answers:
```
3.1415926535897932384
1.7724538509055160272
1.4645918875615232630
1.3313353638003897127
1.2572741156691850593
1.2102032422537642759
1.1776640300231973966
1.1538350678499894305
1.1356352767378998683
1.1212823532318632987
1.1096740829646979321
1.1000923789635869829
```
  
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~9~~ 8 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
(‚ç≥12)‚àö‚óã1
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qG9qQMCjtgnGJlxAplsQkGloZGHO9aijveC/xqPezYZGmo86Zj2a3m34Hyj2XwEMCgA "APL (Dyalog Extended) ‚Äì Try It Online") (`‚éïPP‚Üê34` is Print Precision: 34 digits; `‚éïFR‚Üê1287` is Float Representation: 128-bit decimal)
`‚óã1`‚ÄÉ\$œÄ√ó1\$
`(`‚Ä¶`)‚àö`‚ÄÉtake the following roots of that:
‚ÄÉ`‚ç≥12`‚ÄÉ**…©**ndices 1 through 12
[Answer]
# JavaScript (ES7), 121 bytes
Computes as many digits as the precision of IEEE 754 allows and hardcodes the other ones.
```
_=>[32384,60272,2630,7127,[n=0]+593,2759,3966,4305,8683,2987,9321,69829].map(v=>(Math.PI**(1/++n)+'').slice(0,~(n==2))+v)
```
[Try it online!](https://tio.run/##Dci7DoIwFADQz7GXXmu5hT6GsjuYuBNiGgTFYEuEMPrr1TOeV9jD2n@mZTvGdB/y6PPNN60iZSvUkgwhaSXRlGSwjV52vHYKydQOldMaKyVrtNr@z1mDTlGJ2llynXiHhe2@YZewPcX1XBSsPHEegR8OINZ56gcm8cui9wTAd8h9imuaBzGnBxsZQP4B "JavaScript (Node.js) ‚Äì Try It Online")
### Commented
```
_ =>                          // input is ignored
[ 32384, 60272, 2630, 7127,   // hard-coded digits for n=1 to n=4
  [n = 0] + 593,              // initialize n to 0, and set this entry to '0593' (n=5)
  2759, 3966, 4305, 8683,     // hard-coded digits for n=6 to n=9
  2987, 9321, 69829           // hard-coded digits for n=10 to n=12
].map(v =>                    // for each entry in the above array:
  (Math.PI ** (1 / ++n) + '') //   increment n; compute œÄ**(1/n) and coerce it to a string
  .slice(0, ~(n == 2))        //   remove the last 2 digits if n=2,
                              //   or only the last digit otherwise
  + v                         //   append the hard-coded digits
)                             // end of map()
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + bc ~~+ coreutils~~, ~~51~~, ~~40~~, ~~39~~, 36 bytes
following @ChristianSievers comment `|cut -c -21` could be removed.
-3 bytes thanks to @DigitalTrauma.
```
echo "e(l(4*a(1))/"{1..12}");"|bc -l
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I19BKVUjR8NEK1HDUFNTX6naUE/P0KhWSdNaqSYpWUE35/9/AA "Bash ‚Äì Try It Online")
Some explanations
* `bc -l` define math functions and set scale to 20, see `man bc` for more details
* `a()` atan function, so `4*a(1)` is `pi`
* `e()` exp function
* `l()` log function, so `e(l(x)/y)` is `x^(1/y)`
[Answer]
# [Julia 1.0](http://julialang.org/), 18 bytes
```
@.œÄ^(1/big(1:12))
```
[Try it online!](https://tio.run/##Hc67CsJAFITh2n2KQRETEHVTCkJaKy0sRVD2diSeld0T1FS@oY8UNeX8xcdc24bO@tl3m4v1xH29@LxPhV5eyBd6rauy7C0b1WZij30iFqfqHOIDHSaIxjQvSLC4p@jT@Qahm82IrSAyDtsdHiThPyVQVi4mOBCjU6P6PmjFeLqotDvyeO7KHzlUVBqGPElGjoNfrSSAMs8EKbZsrFG/X/0X "Julia 1.0 ‚Äì Try It Online")
`(1./big(1:12))` divides a `BigInt` 1 by each of 1 thru 12, then `œÄ.^` raises pi to each of those values. So long as there is one `BigInt` or `BigFloat` involved in each computation, it will calculate the result at that precision. The `@.` macro transforms the code to add dots to every function call (thus the dots that appear in my explanation that don't appear in the code snippet), this causes it to "broadcast" which for this purpose means do it all elementwise.
20->19 thanks to Robin Ryder
19->18 thanks to TimD
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~22~~ ~~20~~ 19 bytes
-2 bytes thanks to game0ver
-1 byte thanks to LegionMammal978
```
Pi^(1`11/Range@12)&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE7872b7PyAzTsMwwdBQPygxLz3VwdBIU@2/W3Ts//@6BUWZeSUA "Wolfram Language (Mathematica) ‚Äì Try It Online")
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~47~~ ~~43~~ 40 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
‚Ä¢u¬¨≈ío¬°√µ‚â†√éƒÜŒ∂w1√Å4¬º¬©√©√üw‚Äìx√π√≥1O‚Ä¢5√¥Œµ≈æqN>zm16¬£√¨
```
-7 bytes thanks to *@Grimy*.
[Try it online.](https://tio.run/##AVAAr/8wNWFiMWX//@KAonXCrMWSb8Khw7XiiaDDjsSGzrZ3McOBNMK8wqnDqcOfd@KAk3jDucOzMU/igKI1w7TOtcW@cU4@em0xNsKjw6z/XcK7/w)
Uses the legacy version, because for some reason [the new version outputs \$1.0\$ for \$\pi^{\frac{1}{1}}\$](https://tio.run/##yy9OTMpM/f//6L5Cw6rc//8B).. :S
**Explanation:**
```
‚Ä¢u¬¨≈ío¬°√µ‚â†√éƒÜŒ∂w1√Å4¬º¬©√©√üw‚Äìx√π√≥1O‚Ä¢
             # Push compressed integer 323846027232630971275059342759739669430598683329877932169829
 5√¥          # Split it into parts of size 5:
             #  [32384,60272,32630,97127,50593,42759,73966,94305,98683,32987,79321,69829]
Œµ            # Then map each integer to:
   N>        #  Take the 0-based map-index, and increase it by 1
     z       #  Calculate 1/(index+1)
 ≈æq   m      #  Then calculate PI the power of this
       16¬£   #  Only leave the first 16 characters (including decimal dot)
          √¨  #  And prepend it before the current integer we're mapping
             # (after which the mapped result is output implicitly)
```
[See this 05AB1E tip of mine (sections *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `‚Ä¢u¬¨≈ío¬°√µ‚â†√éƒÜŒ∂w1√Å4¬º¬©√©√üw‚Äìx√π√≥1O‚Ä¢` is `323846027232630971275059342759739669430598683329877932169829`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~61~~ ~~69~~ 63 bytes
Variant of Jitse's [answer](https://codegolf.stackexchange.com/questions/195268/pi-to-the-power-y-for-small-ys/195272#195272), who wants to stick to standard libraries. As mentioned by @Seb & @Jitse, `Rational` or `E/E` are needed because `1/i` isn't precise enough as float.
```
from sympy import*;i=E/E
while i<13:print(N(pi**(1/i),99));i+=1
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P60oP1ehuDK3oFIhM7cgv6hEyzrT1lXflas8IzMnVSHTxtDYqqAoM69Ew0@jIFNLS8NQP1NTx9JSU9M6U9vW8P9/AA)
As a bonus, [`sympy`](https://www.sympy.org/en/index.html) allows to output 99 decimals with the same byte count as for 20 decimals:
```
3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211707
1.77245385090551602729816748334114518279754945612238712821380778985291128459103218137495065673854467
1.46459188756152326302014252726379039173859685562793717435725593713839364979828626614568206782035382
1.33133536380038971279753491795028085330936622381810425845370748286670076101723561496824589105670695
1.25727411566918505938452211411044829390616631003965817353418162262716270074393519788994784267497245
1.21020324225376427596603076175994353105276255513631810467305643780646240044814351479113420061960303
1.17766403002319739668470085583704641096763145003350008756991802723553566109741289228117335907046316
1.15383506784998943054096521314988190017738887987082462087415032873413337243208073328092932090341440
1.13563527673789986837981146453309184806238366027985302804182074656192075351096762716281170420998022
1.12128235323186329872203095522015520934269381296656043824699758762377264153679046528721553289724806
1.10967408296469793211291254568401340513968966612239757917494488030006513039871082996506101420959919
1.10009237896358698298222864697784031503277459309498017808547779493972810083028975298933600450861044
```
[Answer]
# [Python 3](https://docs.python.org/3/), 91 bytes
```
import fractions as f;p=f.Decimal('%s2384'%f.math.pi);i=p/p
while i<13:print(p**i**-1);i+=1
```
[Try it online!](https://tio.run/##DcpBDoMgEAXQfU/Bxqg0xSBdmCo7L0KMhJ8ITGCSpqfHvvWjH4ecTGuIlAsLX9zByKkKV4VfyXq1nweiu4a@q7NZ3n3nVXQcFGFcYWmixzfgOgU2bT5UkHggKSHlS//D0@rWbg "Python 3 ‚Äì Try It Online")
*-23 bytes thanks to flornquake*
[Answer]
# [bc](https://www.gnu.org/software/bc/manual/html_mono/bc.html) -l, 28
```
for(;i<12;)e(l(4*a(1))/++i)
```
[Try it online!](https://tio.run/##S0r@/z8tv0jDOtPG0MhaM1UjR8NEK1HDUFNTX1s7U5Pr//9/@QUlmfl5xf91cwA "bc ‚Äì Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-rbigdecimal/math`, ~~65~~ 50 bytes
Conveniently, even though `BigMath.PI(9)` only *guarantees* precision up to 9 digits, it actually is precise up to 26, which is enough to calculate the exponents, which use the builtin `Rational` fractions instead of floats to ensure the precision is still good enough. (Also, making a `Rational` saves a byte over dividing it normally, since Ruby uses integer division if both arguments are integers, necessitating the use of `1.0` somewhere in the code.)
-15 bytes from histocrat!
```
1.upto(12){|i|puts BigMath.PI(9).**(1r/i).to_s ?F}
```
[Try it online!](https://tio.run/##KypNqvz/31CvtKAkX8PQSLO6JrOmoLSkWMEpM903sSRDL8BTw1JTT0tLw7BIP1NTryQ/vljB3q32//9/@QUlmfl5xf91i5Iy01NSkzNzE3P0c4F6AA "Ruby ‚Äì Try It Online")
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 20 bytes
```
vector(12,n,Pi^n^-1)
```
[Try it online!](https://tio.run/##K0gsytRNL/hfZvu/LDW5JL9Iw9BIJ08nIDMuL07XUPN/QVFmXolGmeZ/AA "Pari/GP ‚Äì Try It Online")
(TIO needs some supporting code, but this works as is in the REPL.
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 268 bytes
```
#1&"3.1415926535897932384
1.7724538509055160272
1.4645918875615232630
1.3313353638003897127
1.2572741156691850593
1.2102032422537642759
1.1776640300231973966
1.1538350678499894305
1.1356352767378998683
1.1212823532318632987
1.1096740829646979321
1.1000923789635869829"
```
[Try it online!](https://tio.run/##Hc8xboNRCAPgvcdIpYwR2GDgPFHXSlHb8//lZf2QLfN8/X19//5c16ffb3x4eA6UzJ4agh0f/qhCJDttLNNlKKyGIse7K@UJQrRV0smk2GbcEketIgsV7iltJC2HR91gRADJUqByVr1KCqMZ6FMc6egOYJqqY6YnaHmUKSZKxep19el1OBq7YgtaxPTZ4DaqsMYo9P7O32o2OOktas2eb9f1Dw "cQuents ‚Äì Try It Online")
There is no way to get more precision out of floats in cQuents, so the values must be hardcoded as strings.
# [cQuents](https://github.com/stestoltz/cQuents), 11 bytes
```
#12&`p^(1/$
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/X9nQSC2hIE7DUF/l/38A "cQuents ‚Äì Try It Online")
Does not reach the required precision levels.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 23 bytes
```
vpa(pi,22).^(1./(1:12))
```
[Try it online!](https://tio.run/##Hc87agNhDATgPifZhbCWZvT0YQImpHBlF8bX3@h3@4kZRo/f1@39d57v52173r@B/fjZ9LhselXs@3nyUFNvhNOrswmWfemRCXOWS4u7hiAxamHeWpUe6iCCMkoq6QyWCKdEkaPwRJqqR0zExZtLVSCEAc4MQ3qPamaECUVA7WRHLJ0BdIks6642ii@lBx0ZyazxqNWrUBRmxRRUEF1rg0pHmhQ6LD7f6UdFGis9RRU9538 "Octave ‚Äì Try It Online")
Declares a variable precision arithmetic (VPA) pi. Octave then cleverly infers that the double constant `pi` actually means pi, not whatever the double constant contains.
[Answer]
# [R](https://www.r-project.org/) + Rmpfr, 80 bytes
Requires package [Rmpfr](https://cran.r-project.org/web/packages/Rmpfr/index.html).
```
mpfr("1.00000000238982476721842284052415179434",30 *log2(10))^(479001600/(1:12))
```
Gives the following, with truncations mine and some minor formatting
```
12 'mpfr' numbers of precision  99   bits 
3.1415926535897932384... 
1.7724538509055160272...
1.4645918875615232630...
1.3313353638003897127...
1.2572741156691850593... 
1.2102032422537642759...
1.1776640300231973966... 
1.1538350678499894305...
1.1356352767378998683... 
1.1212823532318632987...
1.1096740829646979321...  
1.1000923789635869829...
```
See below for why simpler versions don't work. Direct calculation using exponents 1/N for N=1,12 returned inaccurate value fairly early. I figured that was probably due to R or Rmpfr rounding 1/3 early, so whole number exponents would be preferred. So I calculated pi^(12!) (12!=479001600) using Mathematica, then raised it to the power of 12!/N, which would always be a whole number. I had to further tune it by passing the number to Rmpfr as a character vector (so R wouldn't round it), and by using an arbitrarily high precision in both Mathematica and Rmpfr so it would truncate accurately. Because of those arbitrary additions, I can probably shave off a few bytes, but I'm good with it as is.
# ~~[R](https://www.r-project.org/), 29 bytes~~
This only works if R value for pi is accurate, which it isn't. Even reassigning the variable pi to a more accurate representation does not improve accuracy, as it rounds or something around 17 decimals.
```
format(pi^(1/1:12),nsmall=20)
```
[Try it online](https://tio.run/##K/r/Py2/KDexRKMgM07DUN/QytBIUyevODcxJ8fWyEDz/38A)
Or, for 30 bytes
```
options(digits=20);pi^(1/1:12)
```
There's a package that gives a more accurate value for pi and other floating point numbers, [Rmpfr](https://cran.r-project.org/web/packages/Rmpfr/index.html), which you'll find referenced in [questions about pi in R](https://stackoverflow.com/a/31925622). One might expect the following to give the desired output.
```
library(Rmpfr)
Const("pi",20 *log2(10))^(1/1:12)
```
It doesn't. It gives
```
12 'mpfr' numbers of precision  66   bits   
[1] 3.1415926535897932385  1.7724538509055160273  1.464591887561523232
[4] 1.3313353638003897128 1.2572741156691850754 1.2102032422537642632
[7]  1.177664030023197386 1.1538350678499894305 1.1356352767378998604
[10] 1.1212823532318633058 1.1096740829646979353 1.1000923789635869772
```
This is wrong on all counts by rounding or being a few off in the last digits (sidenote: the rnd.mode flag for mpfr does not fix this). Now one might think if we went up to many digits (say 100), then it would surely be correct to the first 20 digits. Nope
```
12 'mpfr' numbers of precision  332   bits 
 [1] 3.1415926535897932384...
 [2] 1.7724538509055160272...
 [3] 1.4645918875615232319...
 [4] 1.3313353638003897127...
 [5] 1.2572741156691850753...
 [6] 1.2102032422537642631...
 [7] 1.1776640300231973859...
 [8] 1.1538350678499894305...
 [9] 1.1356352767378998603...
[10] 1.1212823532318633058...
[11] 1.1096740829646979353...
[12] 1.1000923789635869771...
```
(Truncations mine). These don't all match OP or the other responses.
[Answer]
# C (gcc [`-lm`](https://codegolf.meta.stackexchange.com/questions/14337/command-line-flags-on-front-ends)), ~~171~~ ~~131~~ 122 bytes
Shaved off ~~40~~ 49 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
```
i;p(){for(;i<12;)printf("%.14f%d ",pow(acos(~fesetround(1024)),1./++i),L"Á∫ÄÓ≠∞ÁΩ∂ó≠ßÏñ°ÍúáíÉÆóÅ°òÖªËÉõìóôëÉÖ"[i]);}
```
[Try it online!](https://tio.run/##AZoAZf9jLWdjY///aTtwKCl7Zm9yKDtpPDEyOylwcmludGYoIiUuMTRmJWQgIixwb3coYWNvcyh@ZmVzZXRyb3VuZCgxMDI0KSksMS4vKytpKSxMIue6gO6tsOe9tvCXrafslqHqnIfwkoOu8JeBofCYhbvog5vwk5eZ8JGDhSJbaV0pO33/bWFpbigpe3AoKTt9//5jZmxhZ3P/LWxt "C (gcc) ‚Äì Try It Online")
Output:
```
3.1415926535897932384 1.7724538509055160272 1.4645918875615232630 1.3313353638003897127 1.2572741156691850593 1.2102032422537642759 1.1776640300231973966 1.1538350678499894305 1.1356352767378998683 1.1212823532318632987 1.1096740829646979321 1.1000923789635869829
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/) with [libquadmath](https://gcc.gnu.org/onlinedocs/gcc-4.6.4/libquadmath/), 107
* 2 bytes saved thanks to @ceilingcat.
This uses `__float128` to get the required precision.
```
#import<quadmath.h>
s[9];main(i){for(;i<13;puts(s))quadmath_snprintf(s,36,"%.99Qf",expq(logq(M_PIq)/i++));}
```
[Try it online!](https://tio.run/##Ncy7CsIwFADQ3c@oCDc0rUhBCCnuDoLOIiVEkwbyvikI4q8bp@6HIzstZa1b42LIZUyLeDpR5n4@bfDOHtwJ48GQjwoZuBkPA49LQUBCVjqhj9n4ogDpcKTNrmfsphr6escENugEl@l6TmRv2pYQ/q31J5UVGmtn1@MP)
---
I was curious to try this using the GNU MPFR library too:
# [C (gcc)](https://gcc.gnu.org/) with [libmpfr](https://www.mpfr.org/mpfr-current/mpfr.html), 123
* 13 bytes saved thanks to @ceilingcat.
```
#include<mpfr.h>
i;main(){MPFR_DECL_INIT(p,99);for(;i<12;){mpfr_const_pi(p,99);mpfr_root(p,p,++i,MPFR_RNDN);mpfr_printf("%.19Rf\n",p);}}
```
[Try it online!](https://tio.run/##S9ZNT07@/185M7cgv6jEJrcgrUgvw44rNzEzTyNTs9o3wC0o3sXV2Sfe088zRKNAx9JS0zotv0jDOtPG0NgapDy@oCgzryRNQ0lVz9IyKC0mT0mnQFMTLJOcn1dcEl@QCdGnAxYrys8vAfILdDK1tXUMNK1r////l5yWk5he/F83B6QCAA)
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 30 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ôºñ¬´ÔΩõ‚Äú‚â•Œ±ÔΩôÔº®T.‚îÄÔº£¬π‚Äû1.0000≈ó‚î§‚Äú^m‚Äû‚îò√∑ÔºæÔºΩ
```
[Don't try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjE2JUFCJXVGRjVCJXUyMDFDJXUyMjY1JXUwM0IxJXVGRjU5JXVGRjI4VC4ldTI1MDAldUZGMjMlQjkldTIwMUUxLjAwMDAldTAxNTcldTI1MjQldTIwMUMlNUVtJXUyMDFFJXUyNTE4JUY3JXVGRjNFJXVGRjNE,v=8) It'll take a while to calculate all those digits (it took ~15 minutes to run for me). Rather, [here's](https://dzaima.github.io/Canvas/?u=JXVGRjEzJXVGRjVCJXVGRjE5JXVGRjBCJXUyMDFDJXUyMjY1JXUwM0IxJXVGRjU5JXVGRjI4VC4ldTI1MDAldUZGMjMlQjkldTIwMUUxLjAwMDAldTAxNTcldTI1MjQldTIwMUMlNUVtJXUyMDFFJXUyNTE4JUY3JXVGRjNFJXVGRjNE,v=8) a version of the same code, only outputting the last 3 items.
Computes `C ^ (27720/N)` where `C` is the hard-coded constant `pi^(1/27720)` = `1.000041297024626834690309` and N is looped over from 1 to 12. The big number library decided to expand the amount of significant digits for successively bigger N, making the code take unreasonable amounts of time to run.
[Answer]
# [Python 3](https://docs.python.org/3/), 146 bytes
```
import math
for i in range(1,13):print(str(math.pi**(1/i))[:~(i==2)]+str([32384,60272,2630,7127,'0593',2759,3966,4305,8683,2987,9321,69829][i-1]))
```
[Try it online!](https://tio.run/##Fco7EoIwEADQ3lOkI8FVk13yY4aTMBQUKlsQMjGNjVePQ/1e/tbtSNQa7/koVexr3S6vowgWnERZ0/spDRhSYy6cqvzUIs9zz9z30jxYqXn8SZ4mVMv11JmQwgBOo0dARxq8QQ@dtpE6QG8jUHQOBtIWggsEGIOHSGjAxYBxmflmFqVa@wM "Python 3 ‚Äì Try It Online")
This uses a similar method to Arnauld's JavaScript solution, by using the inbuilt pi value with the extra precision added to the end.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 46 bytes
```
12ƒ∞‚Ç¨√òP*√ó»∑19·∏û+‚Äú·πæ·∫è‚ÅΩ)¬¨·ªç∆ì·ª¥¬≥…≤·ªäU·ªã&ƒ±ƒ∞·∏£l‚Äô·∏É4»∑¬§_2»∑D;"‚Ç¨‚Äù.
```
[Try it online!](https://tio.run/##AWUAmv9qZWxsef//MTLEsOKCrMOYUCrDl8i3MTnhuJ4r4oCc4bm@4bqP4oG9KcKs4buNxpPhu7TCs8my4buKVeG7iybEscSw4bijbOKAmeG4gzTIt8KkXzLIt0Q7IuKCrOKAnS7/wqJZ/w "Jelly ‚Äì Try It Online")
Similar to some other answers, but encodes the difference between the Jelly answer and the correct answer (with big integer arithmetic). Full explanation to follow. 
[Answer]
# Java 10, ~~316~~ ~~299~~ ~~268~~ 259 bytes
```
v->Math.PI+"2384 1.7724538509055160272 1.4645918875615232630 1.3313353638003897127 1.2572741156691850593 1.2102032422537642759 1.1776640300231973966 1.1538350678499894305 1.1356352767378998683 1.1212823532318632987 1.1096740829646979321 1.1000923789635869829"
```
-40 bytes by just hard-coding the output instead of calculating it.. >.>  
-9 bytes thanks to *@ceilingcat*.
[Try it online.](https://tio.run/##LZDBSgNBDIbvfYqhpy3ikkkmyYSidw8tguBFPKzbqlu329LdLoj02dcZ7SWQL@Tn59tVY3W723xNdVv1vVtVTfczc67phu3pvaq3bp1X556GU9N9uLp4PjQbNy6WiV5mafRDNTS1W7vO3blpvL1fVcNn@fhwM0eKwflSFQNTZDBg9gKomGiQwOZjVBbPSCgEiRJ5IiahCEDR1KMmiqyowXsWSS8MbJSpBwTCgMikElDZEvWqIgEIAMmbkolkmgoQg2gMZtECAWdKLMSooqQxcYk516PHiKlFCohCaDF38GCiASKaBDE1Qv9HAQzzdwqKYuk8n5ZZy/H81iYtVztjlrZPbot/jy@vrlpcxX73w3ZfHs5DeUynoe2KrqyL7ty2i6vly/QL)
**Old ~~299~~ 291 bytes answer with actual calculations..**
```
v->{var P=new java.math.BigDecimal(Math.PI+"2384");var x=P;for(int i=0;++i<13;System.out.println(x)){var p=P;for(x=P.divide(P.valueOf(i),21,5);x.subtract(p).abs().compareTo(P.ONE.movePointLeft(22))>0;)x=P.valueOf(i-1).multiply(p=x).add(P.divide(x.pow(i-1),21,5)).divide(P.valueOf(i),21,5);}}
```
Not entirely precise, but good enough to have the first 20 digits correct.
[Try it online.](https://tio.run/##fZA/b8IwEMV3PsWJyRZgQWilSm4YqnaoVCASFUvVwTgONfU/JY4JQvnsqQOIsYut8917z/c7sMAmh/y344pVFSyZNOcBgDRelAXjAlZ9CRCszIGjbX8FTONbO4hH5ZmXHFZgIIUuTBbnwErIUiOOcIjWRDP/Q17k/lVwqZlCy77O3kfDZP70MMS0H2/SjBa2RDEUZDqlo5F8ns3p5lR5oYmtPXFl7CmDGowvAe6miEqSyyBzgTISmKrFukASj5PZ@BHThlT1zpeMe@QwYbsKYcKtdqwUnzYK1qs3om0QmY3uH6LwKEkwXkwp7n3vdpMZJrpWXjp1Qi5tolWeo3twQ5w9XqausfifH7VtR3tsrt6piO1G78JWR/Jo4@Oi@69vYPiK3RCOTK3UjXjb/QE)
**Explanation:**
Most bytes come from the fact that `BigDecimal` doesn't have a builtin for `BigDecimal.pow(BigDecimal)` nor the \$n\$th root, so [we'll have to calculate this manually](https://stackoverflow.com/a/34074999/1682559)..
```
v->{                         // Method with empty unused parameter and no return-type
  var P=new java.math.BigDecimal(Math.PI+"2384");
                             //  Create a BigDecimal for PI
  var x=P;                   //  Create a BigDecimal to print after every iteration
  for(int i=0;++i<13;        //  Loop `i` in the range [1,12]:
      System.out.println(x)){//    After every iteration: print `x` to STDOUT
    var p=P;                 //   Create a BigDecimal to save the previous value
    for(x=P.divide(P.valueOf(i),
                             //   Set `x` to PI divided by `i`
                   21,5);    //   (with precision 21 and rounding mode HALF_DOWN)
                             //   Continue an inner loop as long as:
        x.subtract(p).abs()  //   The absolute difference between `x` and `p`
         .compareTo(P.ONE.movePointLeft(22))>0;)
                             //   is larger than 1e-22
      x=                     //    Set `x` to:
        P.valueOf(i-1)       //     `i-1`
         .multiply(p=x)      //     Multiplied by `x` (and store the previous `x` in `p`)
         .add(               //     And add:
          P.divide(          //      PI divided by
           x.pow(i-1),21,5)) //      `x` to the power `i-1`
         .divide(P.valueOf(i),21,5);}}
                             //     Divided by `i`
```
[Answer]
# [Perl 5](https://www.perl.org/), 72 bytes
```
$n=1;print substr(Math::BigFloat->bpi()**(1/$n++),0,21).$/ while($n<13);
```
Even using \$\pi\$ from BigFloat, it doesn't seem to exactly match the given outputs. I'm sure it's truncated properly, though.
[Try it online!](https://tio.run/##K0gtyjH9X1qcquCbWJJhZRVSlJluzYXgO2Wmu@XkJ5ZYc/1XybM1tC4oyswrUSguTSouKdJAVaJrl1SQqaGppaVhqK@Sp62tqWOgY2Soqaeir1CekZmTqqGSZ2NorGn9/z8A "Perl 5 ‚Äì Try It Online")
[Answer]
# [Fortran (GFortran)](https://gcc.gnu.org/fortran/), 48 bytes
```
print*,(acos(-1._16)**(1/real(i,16)),i=1,12)
end
```
[Try it online!](https://tio.run/##Jc9NbsJQDATgPScJUaC2x7@LnqWKWqgiVVAF7p86dOf3PXk0vt7X5zrfTt/X/2Hbftfl9hynYf68P4YTnz/Yj@M48Nt6mX@GZerncVreeWI5Hi63r23DmZWtxA2WFQVB6oHPEaKGNCoyYycJaVVXK84MczaBOKgVYMDgSCJ0CEu0ioWEMpt7rxhZYVcmIYiKGMJVwqqVI9yVQCTgCpT7rl0ARh6pVVkKsl1hDpPwQGS7557LwpLSLTogHVK5d2AqD6WUcvXXdfxSopJ9u4PSq7//AA "Fortran (GFortran) ‚Äì Try It Online")
Just an implicit loop with quad-precision vars. Not transferable, but works with GCC.
]