# How bright would the night sky be in the galactic center?

Given that the star density within a parsec of the center of the Milky Way is about 10 million stars per cubic parsec, how bright would the night sky be if you were on a rocky planet within that region?

As this is 10 million stars within a cube with an edge 23% smaller than the distance to our nearest star, I get that the sky would be absolutely littered with stars. But qualitatively, what it would be like: e.g. would the light be be excruciatingly blinding (other effects aside), would it be like a really, really bright day here on Earth, or would it perhaps still be dimmer than our daytime illumination?

Would the black of a night sky even be visible from a planet with an atmosphere similar to our own, or would the sky just be awash with (scattered) light, leaving human eyes (or consumer-grade digital cameras) unable to resolve individual stars?

• here is a somewhat related question... what would gravity feel like in that region if you were on an earthlike planet in a solar system like earth's? Certainly the dominant force(s) would the system's star and on a habited planet that planet's gravity. But how 'diluted' might that force be by so much nearby mass? Jun 30, 2022 at 13:34

Interesting question. Assuming the figure of 10 million stars per cubic parsec is correct, there's still one missing piece of information to try getting a estimate: The size of this region with a very high concentration of stars. But at least we know it can't go very far, because at such densities (d), it would take a sphere with radius r = (3 *10^11 / 4 * pi * d)^(1/3) ~= 6.2 parsecs to hold about 100 billion stars, on the order of the actual number of stars in the entire galaxy. So I will guess this region of high star density (r) holds only about 1% of that, corresponding to a radius of (3 *10^9 / 4 * pi * d)^(1/3) ~= 1.34 parsecs.

To get a estimate of the brightness of the sky near the galactic center, I coded a simulation using Pharo 10 (a Smalltalk dialect):

This simulation just populates a spherical region of space randomly with points representing stars, assigning each of then a power output following the distribution of known stars near the solar system. Then it sums the luminance component of each star above a plane that passes through the center, and perpendicular to it. This is done 10 times and the average is taken, to average out the effect of a particular run where by chance we get a star very close to the center point, where we assume the planet of the observer is located. This estimate makes some assumptions:

• Stars near the core are randomly distributed in every direction;
• Stars don't obstruct each other. Probably mostly true, as the size of the stars is very small, when compared to the distances that separates them;
• The radiation has a path mostly free of dust, doubtful when talking about the Milkyway core;
• Luminance (total W/m^2) is a good proxy for what you would actually see with your eyes. Probably not that realistic, as stars different of the sun radiate a lot of the energy outside the visible spectrum, as ultraviolet or infrared;
• We can take the known stars near the solar system as a representative sample of those near the galactic core. That's doubtful, as there's probably lots of still undiscovered brown and red dwarfs near us, and the near earth sample doesn't contain some kinds of stars that are surely present at the galact center, like red giants, outside the main sequence.

Given those disclaimer, here is the code for the simulation, as executed in Pharo's playground:

| sunPowerOutput au moonAverageDistance moonRadius moonAlbedo sun radii t0 |
sunPowerOutput := 3.828e26. "In W/m^2"
au := 1.5e11. "In meters"
moonAverageDistance := 3.844e8. "In meters"
moonAlbedo := 0.1. "Dimensionless"
radii := #( 0.1675 0.335 0.67 1.34 ). "In parsecs"
sun := CelestialBody
withX: 0
withY: 0
withZ: 0
withPower: sunPowerOutput.
Transcript
clear;
show: 'Solar constant estimate (W/m^2): ';
show: (sun fluxDensity: au);
cr.
moon := CelestialBody
withX: 0
withY: 0
withZ: 0
withPower:
moonAlbedo * (sun fluxDensity: au) * Float pi
Transcript
show: 'Lunar constant estimate (W/m^2): ';
show: (moon fluxDensity: moonAverageDistance);
cr.
Transcript
show: 'Stellar constant estimate (W/m^2): ';
show:
(GalaxyCore withRadius: 150 withDensity: 0.14) centerPowerDensity;
cr.
Transcript
show: ';';
show: 'W/m^2';
cr.
t0 := DateAndTime now.
Transcript
show: ';';
show: (((1 to: 10) collect: [ :each |
centerPowerDensity ]) average round: 4);
cr ].
Transcript
show: 'Done in '
,
(((DateAndTime now - t0) asMilliSeconds / 1000) round: 2) asFloat asString
, ' seconds';
cr


The results, as printed to Pharo's transcript, are as follows:

Solar constant estimate (W/m^2): 1353.8780492350566
Lunar constant estimate (W/m^2): 0.0006914367075657645
Stellar constant estimate (W/m^2): 6.816259502147244e-7
0.1675;0.0649
0.335;0.1195
0.67;0.2405
1.34;0.4689
Done in 577.24 seconds


For comparison, initially I tried to get estimates for the solar constant at Earth orbit starting from the power output of the Sun, getting the estimate of about 1353.88 W/m²; for the full moon constant on the surface of Earth, assuming the Moon reflects 10% of the received solar radiation, getting the estimate of about 0.0007 W/m² (a little short of a milliwatt/m²); and for the stellar constant at the solar system position in the galaxy, assuming that the estimated stellar density of 0.14 stars/parsec³ in the neighborhood of the solar system extends uniformly into a spherical region with diameter about the thickness of the galactic disk, 300 parsecs, getting the estimate of about 6.8e-7 W/m² (a little short of a microwatt/m²).

With those values for context, I ran the simulation for the density informed by the question asker (10⁷ stars/ parsec³), the guessed radius for the high density core region (1.34 parsecs), and also for submultiples of this radius (r/2, r/8 and r/16), so we can have a idea of how the luminance values scale with radius.

The result, for r = 1.34 parsecs is close to half a watt/m², and the scaling with the radius of the region is nearly linear, with a rate of 0.35 W/m² for every parsec. The linear scaling makes sense, when we think about it, as when the size of the region increases, the average power received from each star decreases by r², but their number increases with volume, and so with r³, so the total amount increases proportinonal to r³/r² = r.

The value close to half a watt/m² we got for for a core region with radius of 1.34 parsecs is close to a thousand times the estimate we got for the full moon, spread across the entire sky. So I think the night sky of our putative planet in the core region of the galaxy would resemble our sky at late dusk, but with a much larger number of bright stars spread across the sky, surrounded by the diffuse light of more distant / less luminous stars.

About your question if we would be unable to resolve individual stars, we can try to get a upper bound estimate similar to the one in the answer I gave in this question: How many stars can we resolve?, but instead of using the resolution of the James Webb Space Telescope, we must plug the angular resolution of the naked eye, about 1 arcminute, or 60 arcseconds:

| resolution starsAtEquator starsInHemisphere |
Transcript clear.
resolution := 60. "Resolution in arc-seconds"
starsAtEquator := 360 * 60 * 60 / resolution.
starsInHemisphere := ((0 to: starsAtEquator // 4) collect: [ :each |
(each * Float pi / (starsAtEquator // 2)) cos
* starsAtEquator round: 0 ]) sum.
Transcript
show: 'Stars in whole celestial sphere: ';
show: 2 * starsInHemisphere


The upper-bound estimate we get is:

Stars in whole celestial sphere: 1.48532234e8


So, with the resolution of the naked eye, we can't resolve more than about 150 million individual stars in the whole sky, even if their combined luminous output it's not enough to awash the fainter ones.

I think you can get better estimates than mine, if you tweak the simulation to use a more realistic mass distribution function, probably some kind of continuous power law. I just picked randomly mass values from the stars near the solar system. But that doesn't account for stars with masses lower than the minimum in our solar neighborhood, and specially higher than the maximum. As the power output of stars scales with mass^3.5, by ignoring massive stars I may have incurred in large errors, in my estimate, as massive stars have a disproportional share of the radiation produced. Also it would be good to tweak the simulation to take into account luminous intensity instead of irradiance, to take into account only radiation actually visible to the human eye, not total radiation.

In the main code section shown above, the heavy lifting of the simulation is done by objects from two classes, CelestialBody and GalaxyCore. To ensure replicability, I did a File Out of the package containing the two classes, and copied the contents of the file below. So, if people want to verify the logic, or implementation details, or run it themselves, the contents can be copied to a .st textfile and then the package loaded into a Pharo image:

Object subclass: #CelestialBody
instanceVariableNames: 'x y z powerOutput'
classVariableNames: ''
package: 'MyAstroSimulation'!
!CelestialBody commentStamp: 'KS 6/24/2022 20:19' prior: 0!
I represent a point-like celestial body.

I hold the coordinates for the 3D position of a celestial body, and a luminance value. I can calculate the distance to another CelestialBody object, the flux density at a given distance, for bodies with nonzero power output values.

I collaborate with objects in the CelestialBody class, comprising their star-populations.

Public API and Key Messages

- distanceTo: anotherCelestialBody
- fluxDensity: givenDistance
- New instances can be created by specifying coordinates and power output values: CelestialBody withX: aFloat withY: aFloat2 withZ: aFloat3 withPower: aNumber

Internal Representation and Key Implementation Points.

Instance Variables
powerOutput:        Float
x:      Float
y:      Float
z:      Float

!

!CelestialBody methodsFor: 'initialization' stamp: 'KS 6/6/2022 19:57'!
initialize
"Initializes attributes of a newly created instance, without arguments. Defaults to 0"
"scope: x, y, z, powerOutput"

x := 0.
y := 0.
z := 0.
powerOutput := 0
! !

!CelestialBody methodsFor: 'distance functions' stamp: 'KS 6/11/2022 23:27'!
distanceTo: anotherBody

"Calculates distance between two point-like celestial objects"

"scope: x, y, z"

^ ((x - anotherBody x) squared + (y - anotherBody y) squared
+ (z - anotherBody z) squared) sqrt! !

!CelestialBody methodsFor: 'properties' stamp: 'KS 6/11/2022 23:27'!

"Calculates flux density (W/m^2) at distance aRadius from point-like source, using
inverse-square law."

"scope: powerOutput"

^ powerOutput / (4 * Float pi * aRadius squared)! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:02'!
z
"Gets the Z cordinate"
"scope: z"

^ z! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 19:59'!
x
"Gets the X cordinate"
"scope: x"

^ x! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:00'!
y
"Gets the Y cordinate"
"scope: y"

^ y! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:00'!
x: aFloat
"Sets the X cordinate"
"scope: x"

x := aFloat! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:02'!
y: aFloat
"Sets the Y cordinate"
"scope: y"

y := aFloat! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:07'!
powerOutput: aFloat
"Sets the total power output of the celestial body"
"scope: powerOutput"

powerOutput := aFloat! !

!CelestialBody methodsFor: 'accessing' stamp: 'KS 6/6/2022 20:07'!
z: aFloat
"Sets the Z cordinate"
"scope: z"

z := aFloat! !

"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

CelestialBody class
instanceVariableNames: ''!

!CelestialBody class methodsFor: 'instance creation' stamp: 'KS 6/24/2022 18:47'!
withX: aFloat withY: aFloat2 withZ: aFloat3 withPower: aNumber

"Creates new instance of CelestialBody, with given coordinates and power output value."

"scope: x, y, z, powerOutput"

^ self new
x: aFloat;
y: aFloat2;
z: aFloat3;
powerOutput: aNumber! !

Object subclass: #GalaxyCore
instanceVariableNames: 'radius density volume massDistributionSample population randomCoordinate centerPlanet'
classVariableNames: ''
package: 'MyAstroSimulation'!
!GalaxyCore commentStamp: 'KS 6/24/2022 20:23' prior: 0!
I represent a spherical region in a galaxy.

I create and represent a simulated population of stars, distributed randomly within a spherical region of space. Over this region I can sum the contributions of individual stars to get the cross-sectional power density at a putative planet in the center of the spherical region. I have a random number generator to help populate the sphere, and I know the radius of this region, its star-density and a list of values that represents the mass distribution of stars.

I colaborate with the CelestialBody class, to create stars, to calculate the flux density at a given distance from them, and to calculate distances between them.

Public API and Key Messages

- centerPowerDensity
- Instances are created by specyfying radius and star density: GalaxyCore withRadius: aFloat1 withDensity: aFloat2

Internal Representation and Key Implementation Points.

Instance Variables
centerPlanet:       CelestialBody
density:        Float
massDistributionSample:     Array
population:     OrderedCollection
randomCoordinate:       Random
volume:     Float

Note that the way the class is structured, the objects are meant to have properties fixed at creation, and kept unchanged afterwards. The class doesn't ensure mutual consistency between attributes. For example, if volume is changed after creation, it will become inconsistent with radius.!

!GalaxyCore methodsFor: 'initialization' stamp: 'KS 6/24/2022 18:10'!
initialize

"Initializes the values of a newly created GalaxyCore with default values, when no arguments
are given. massDistributionSample values are taken from the list of all known stars, brown dwarfs,  and sub-brown dwarfs within 5.0 parsecs (16.3 light-years) of the Solar System, as contained in
https://en.wikipedia.org/wiki/List_of_nearest_stars_and_brown_dwarfs (when a interval was given,
instead of point estimates, the average between upper and lower bound was used)."

"scope: centerPlanet, radius, density, volume, massDistributionSample, randomCoordinate,
population"

centerPlanet := CelestialBody new.
density := 0.
volume := 0.
massDistributionSample := #( 2.063 1.499 1.079 1.018 1 0.909 0.82
0.81 0.783 0.754 0.75 0.7 0.67 0.67 0.63
0.602 0.6 0.486 0.48 0.465 0.45 0.401
0.39 0.38 0.37 0.35 0.334 0.294 0.281
0.271 0.26 0.248 0.223 0.176 0.17 0.168
0.15 0.144 0.143 0.14 0.136 0.131 0.13
0.122 0.113 0.111 0.11 0.11 0.11 0.11
0.11 0.102 0.1 0.1 0.1 0.1 0.09 0.09
0.08 0.08 0.08 0.07 0.07 0.065 0.05 0.045
0.032 0.03 0.027 0.0175 0.0065 ).
randomCoordinate := Random new.
population := OrderedCollection new.! !

!GalaxyCore methodsFor: 'instance initialization' stamp: 'KS 6/24/2022 12:52'!
populateOctant

"Creates a population of stars, to represent the core. To speed up the calculations, the    population holds a single octant-worth of stars. As the sphere is a highly symmetrical solid,
the contribution calculated for this single octant can be multiplied by 8 to get corresponding
values to the whole sphere, or by 4 in case of a hemisphere. The stars are randomly placed in
a cube, and those farther than the core radius are rejected, to get a octant from the star-cube."

"scope: population, density, volume, radius, centerPlanet, randomCoordinate"

| parsec2meters |
parsec2meters := 3.0857e16.
[ population size < (density * volume / 8) rounded ] whileTrue: [
| star |
star := CelestialBody
withX: radius * parsec2meters * randomCoordinate next
withY: radius * parsec2meters * randomCoordinate next
withZ: radius * parsec2meters * randomCoordinate next
withPower: self powerDistribution.
(star distanceTo: centerPlanet) <= (radius * parsec2meters) ifTrue: [
population add: star ] ]! !

!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/11/2022 23:45'!
density: aFloat
"sets the star density in the galaxy core region (stars/parsec^3)"
"scope: density"

density := aFloat! !

!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/12/2022 00:37'!

"Sets the value for the core radius, in parsecs"

!GalaxyCore methodsFor: 'accessing' stamp: 'KS 6/12/2022 00:38'!
volume: aFloat
"Sets the volume of the core"
"scope: volume"

volume := aFloat! !

!GalaxyCore methodsFor: 'auxiliar' stamp: 'KS 6/24/2022 12:52'!
powerDistribution

"Picks a random value from massDistributionSample, calculates the corresponding power output
(luminosity, see https://en.wikipedia.org/wiki/Luminosity) from this mass and the reference
value for the sun, and returns the result."

"scope: massDistributionSample"

| mass |
mass := massDistributionSample atRandom.
^ 3.828e26 * (mass raisedTo: 3.5)! !

!GalaxyCore methodsFor: 'auxiliar' stamp: 'KS 6/24/2022 16:15'!
centerPowerDensity

"Takes every star from the galaxy core population, calculates its flux density at the center    point of    the core, takes its vertical component ( star z / (star distanceTo: centerPlanet)
equals the sine of the angle equator-center-star) and then sums the results for every star.
As population corresponds to a single octant of the core, multiplies the result by 4, to
represent the flux from the celestial hemisphere visible at a point in the surface of a
putative planet (represented by centerPlanet)."

"scope: population, centerPlanet"

^ 4 * (population collect: [ :star |
(star fluxDensity: (star distanceTo: centerPlanet)) * star z
/ (star distanceTo: centerPlanet) ]) sum! !

"-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- "!

GalaxyCore class
instanceVariableNames: ''!

!GalaxyCore class methodsFor: 'instance creation' stamp: 'KS 6/24/2022 20:00'!

"Creates new GalaxyCore object with given radius and density."

^ self new
density: aFloat2;
volume: (4 / 3) * Float pi * (aFloat1 raisedTo: 3);
populateOctant! !

• Wow, I cannot thank you enough for the amount of thought and work you've put into this! Jun 25, 2022 at 23:21
• Can we see a demo? Nov 27, 2022 at 20:05

From Foundations of Astrophysics by Barbara Ryden and Bradley Peterson (which I highly recommend):

If the Sun were half a parsec from the Galactic center:

. The nearest star would be ∼ 1000 AU away.

. The night sky would contain ∼ 106 stars brighter than Sirius.

. The total starlight would be ∼ 200 times brighter than the full Moon.

...

The bolometric luminosity of Sagittarius A* is not exactly known, due to the high extinction at many wavelengths, but is estimated to be L ∼ 1000L.

• So at night instead of seeing the full moon projecting my kitchen window onto my dark kitchen floor I imagine I would see a projector beam of light coming through the window lighting up most of the floor.. Nov 27, 2022 at 20:15