Technical Specification for the ArcSecs Dual-Tier Physics and Cosmological Simulation Engine

Full report

On this page

The development of interactive web-based physics engines has historically forced a compromise between two conflicting paradigms: the accessibility required for educational platforms and the mathematical rigor demanded by computational physicists, astronomers, and software engineers.1 By analyzing the ArcSecs web physics platform, this technical framework outlines how to design an engine that bridges this gap.4 The engine achieves this by using a dual-tier architecture that exposes complex underlying parameters while providing intuitive visual representations.1 The name "ArcSecs" refers to the arcsecond, a fundamental unit of angular measurement equal to [Figure omitted from source export] of a degree.7 This connection provides an opportunity to expand the engine beyond basic rigid-body dynamics.1 By integrating astronomical optics 11, cosmological redshift theories 13, dark matter halo modeling 15, and relational coordinate-free spacetime emergence 5, the engine connects classical mechanical loops with the mathematical foundations of astrophysics and quantum cosmology.5

Front-End Frameworks and Web Engine Architecture

To maximize accessibility for beginners without sacrificing execution speed, the front-end must support a dual-tier execution loop.1 Beginners require zero-install, declarative HTML elements that render immediate visual feedback.3 In contrast, advanced users require low-overhead API bindings, deterministic execution, and configuration of the underlying solver mechanics.2 The beginner-facing layer is built using encapsulated Web Components, registering custom HTML elements such as \<game-component\>, \<platform-component\>, and \<crate-component\>.3 This design leverages the browser's native DOM parser, allowing users to define scenes through HTML structures.3 Behind these custom elements, a high-performance rendering pipeline uses an HTML5 \<canvas\> element.3 To maintain smooth rendering, the DOM positions of these components are updated via CSS 3D transforms (translate3d), which offloads the drawing overhead to the GPU.3

\+----------------------------------------------------------------------------------------+ | Client-Side Browser Runtime | | | | \+--------------------------------------------------------------------------------+ | | | Visual Presentation Layer (HTML5 DOM) | | | | \<game-component\> | | | | \<crate-component x="10" y="20" mass="5.0"\>\</crate-component\> | | | | \<platform-component is-static="true"\>\</platform-component\> | | | | \</game-component\> | | | \+--------------------------------------------------------------------------------+ | | | | | v | | \+--------------------------------------------------------------------------------+ | | | Dynamic GPU Canvas Renderer | | | | Interpolates Rigidbody States and Translates Vertices via WebGL | | | \+--------------------------------------------------------------------------------+ | | | | | v | | \+--------------------------------------------------------------------------------+ | | | WebAssembly Execution Core (Emscripten / Odin) | | | | \- GJK/EPA Narrowphase \- Gauss-Seidel Constraint Solver | | | | \- Broadphase Spatial Grid \- Fixed-Tick Integrator (120 Hz) | | | \+--------------------------------------------------------------------------------+ | \+----------------------------------------------------------------------------------------+

For advanced users, the JavaScript DOM is bypassed entirely in favor of compiled execution pipelines.2 The engine's core is compiled into WebAssembly (Wasm) using a C++ or Odin compiler toolchain.1 This pipeline utilizes Raylib and Emscripten to enable high-performance calculations directly on the web.2 To support modular code architectures, the engine is packaged using modern TypeScript with .mts and .mjs extensions.18 This approach ensures native ESModule compatibility across server-side Node.js or Deno runtimes and client-side web browsers without requiring heavy bundlers.18 The performance of different web physics engines under stress testing highlights the need for this dual-tier architecture.

Rigid-Body Collision Pipelines and Visual Diagnostics

A major challenge when designing an accessible yet advanced physics simulation is presenting complex spatial and numerical calculations in an understandable format.1 The ArcSecs engine solves this by using real-time visual diagnostics that overlay mathematical constructs directly onto the simulated bodies.6

\\ / v v \+---------------------------------------------------+ | Broadphase: Spatial Grid Partition | | (Prunes non-colliding pairs in O(N) complexity) | \+---------------------------------------------------+ | Colliding Pairs v \+---------------------------------------------------+ | Narrowphase: GJK / SAT Algorithm Pipeline | | (Calculates exact geometric overlap vectors) | \+---------------------------------------------------+ | Separation Axis & Depth v \+---------------------------------------------------+ | Contact Manifold: EPA Face Clipping | | (Determines point of impact, normal vector) | \+---------------------------------------------------+ | Contact Points v \+---------------------------------------------------+ | Sequential Impulse Gauss-Seidel Solver | | (Resolves restitution, friction, & torque) | \+---------------------------------------------------+

Broadphase Spatial Partitioning

To maintain interactive performance, the engine avoids checking every body against every other body, which has a quadratic computational complexity of [Figure omitted from source export].2 Instead, it uses a hierarchical spatial partitioning pipeline.2 Beginners can toggle a visual overlay to view the Axis-Aligned Bounding Box (AABB) trees or spatial grid lines.2 This visualization helps novices understand how the engine groups nearby bodies before calculating exact collisions.2 Advanced users can directly modify the broadphase configuration. They can adjust the cell sizes of the uniform spatial grid 2 or configure the tree-rebuilding heuristic of the dynamic AABB tree.10

Narrowphase Collision and Contact Manifolds

Once the broadphase identifies potential collisions, they are sent to the narrowphase pipeline to calculate exact geometric overlaps.1 The engine supports multiple colliders, including spheres, boxes (rectangular prisms), cylinders, static triangles, and planes.1 For advanced configurations, the system uses two main narrowphase pipelines:

• Separation Axis Theorem (SAT): This method projected vertices along face normals to detect overlaps in box-to-box and box-to-sphere collisions.1 The engine visually renders the calculated projection axes and identifies the "Separating Axis" where overlap is minimized.1
• GJK and EPA Pipeline: For arbitrary convex shapes, the engine uses the Gilbert-Johnson-Keerthi (GJK) algorithm to calculate the minimum distance between bodies in Minkowski space.10 If an overlap is detected, the Expansion Polytope Algorithm (EPA) expands the Minkowski difference hull outward.10 This process calculates the exact penetration depth vector and generates a contact manifold via face clipping.10

To make this understandable to beginners, the engine displays interactive vectors of these mathematical operations.6 Red arrows represent the penetration depth, yellow circles mark the contact points, and blue lines show the surface contact normals.6

Numerical Integration and Constraint Resolution

Once the contact manifold is generated, the engine resolves the physical forces, torques, and constraints.1 The rigid-body states are advanced over time using semi-implicit Euler integration.1 This integration maps forces and torques to linear and angular velocities before updating positions and orientations 1: [Figure omitted from source export] [Figure omitted from source export] Resting contacts, spring connections, and joint constraints are formulated as a system of inequalities solved using an iterative projected Gauss-Seidel solver.10 To make this numerical process understandable, the interface provides visual diagnostics that show how forces are resolved 6:

• Velocity and Force Vectors: Real-time green arrows scale with the linear velocity of each body, while orange curved vectors represent angular velocity and torque.1
• Constraint Island Coloring: When multiple bodies contact each other, the engine groups them into isolated computational units called "islands".6 By color-coding these islands in real time, the engine visually demonstrates how forces propagate through stacked objects.6
• Fixed-Time Step Manipulation: Novices often struggle to understand why simulation physics break at high velocities.18 The engine provides a step-by-step control panel.6 Users can pause the simulation, manually execute a single frame, adjust the time-step duration ([Figure omitted from source export]), or configure the maximum sub-steps.6 This interactive control demonstrates how numerical integration error grows when the time step is too large relative to the velocities involved.1

Astronomical Optics and Plate Scale Metrics

The term "arcsec" is a foundational unit of angular resolution in astronomical optics and stellar astrometry.7 To bridge physics simulation with astronomical observation, the platform includes an interactive optics module.11 This module simulates how light behaves across different optical apertures, focal lengths, and detector pixel dimensions.11

Aperture (D) \+------------+ | | | \\ / | | \\ / | | \\ / | | \\ / | Focal Length (F) | \\/ | | /\\ | | / \\ | | / \\ | | / \\ | | / \\ | \+------------+ Focal Plane (CCD Sensor with Pixel Size w)

Trigonometric Parallax and Proper Motion

The arcsecond is historically defined through trigonometric stellar parallax, where the distance of one parsec ([Figure omitted from source export]) is the distance at which an astronomical unit ([Figure omitted from source export]) subtends an angle of exactly one arcsecond ([Figure omitted from source export]).7 This relationship is governed by the small-angle approximation 9: [Figure omitted from source export] where [Figure omitted from source export] is the parallax angle in arcseconds.9 The simulation lets users interactively adjust the baseline distance (e.g., Earth's orbit of [Figure omitted from source export]) and observe the apparent motion of a target star against distant, stationary background stars.9 By incorporating proper motion ([Figure omitted from source export]) measured in arcseconds per year, the engine calculates the tangential velocity ([Figure omitted from source export]) of stellar bodies 23: [Figure omitted from source export] To convert this value to metric SI units ([Figure omitted from source export]), the engine computes the conversion factor between arcseconds, parsecs, and metric time 23: [Figure omitted from source export] This calculation shows how a proper motion of one arcsec per year at a distance of one parsec corresponds to a tangential velocity of [Figure omitted from source export].23 The engine's conversion database is structured to bridge these astronomical scales with standard metric SI units.7

Plate Scale Calculations

For advanced users studying astrometry and focal plane imaging, the engine simulates plate scale dynamics.12 This system determines how many arcseconds of the sky map onto a physical millimeter of an image sensor 12: [Figure omitted from source export] where [Figure omitted from source export] is the focal length of the telescope, and [Figure omitted from source export] is the number of arcseconds in one radian.12 To translate this physical metric to pixel-level data on a modern charge-coupled device (CCD), the engine implements the standard camera plate scale formula 12: [Figure omitted from source export] where [Figure omitted from source export] represents the physical width of a single pixel in micrometers.12 Beginners can interactively adjust the focal ratio ([Figure omitted from source export]\-ratio) and pixel size to observe how these parameters affect image scale.12 Fast focal ratios (small [Figure omitted from source export]\-ratios) increase the light per pixel but cover more arcseconds per pixel, which reduces the spatial resolution.12 Advanced users can simulate high-precision research instruments by loading specific aperture and focal configurations into the optics panel.11

Cosmological Models: Expanding Space versus Static "Tired Light"

To provide a playground for advanced theoretical physics, the engine includes a cosmological wave simulation module.14 This module lets users contrast standard expanding FLRW cosmologies with historical alternatives, such as Fritz Zwicky’s 1929 "tired light" proposal.14

Expanding Space (FLRW) Source \ \===(Wavelength Stretches)===\> \[Observer\] \- Photon energy decreases: E \= E0 / (1 \+ z) \- Arrival rate decreases due to time dilation: dt\_obs \= dt\_src \ (1 \+ z) \- Surface Brightness dims dramatically: I \~ (1 \+ z)^-4

Tired Light (Zwicky 1929\) Source \ \===(Energy Lost to Space Resistance)===\> \[Observer\] \- Photon energy decreases exponentially: E \= E0 \ e^(-d/R) \- No cosmic expansion or time dilation: dt\_obs \= dt\_src \- Surface Brightness dims gently: I \~ (1 \+ z)^-1

Pure Kinematics vs. Relativistic Dynamics

The engine lets users compare different expansion dynamics.27 For example, users can toggle the kinematics of the Edward Arthur Milne model against standard Friedmann-Lemaître-Robertson-Walker (FLRW) dynamics.27 The Milne model describes a kinematically expanding universe of non-interacting test particles moving at constant velocity.27 This kinematic model produces an apparent linear relationship between velocity and distance, mimicking Hubble's law ([Figure omitted from source export]) without requiring gravitational curvature or dynamic dark energy.27 Advanced users can toggle this kinematic model to observe how it compares to standard general relativistic expansion.27 In the general relativistic model, expansion rates are dynamically determined by the matter, radiation, and dark energy densities of the Friedmann equations.27

The Tolman Surface Brightness Test

The core visual tool in this module is the Tolman surface brightness test.13 Surface brightness ([Figure omitted from source export]) measures the received flux density per unit solid angle of an extended astronomical source.12 The engine calculates the apparent surface brightness of simulated galaxies as they are moved to high redshifts ([Figure omitted from source export]) 13:

• Expanding Universe (FLRW Metric): The surface brightness of an expanding universe dims by a factor of [Figure omitted from source export] when using bolometric VEGA magnitudes 13:

[Figure omitted from source export] This dimming is caused by two physical mechanisms.13 First, individual photon energies decrease by [Figure omitted from source export] due to redshifting.13 Second, the photon arrival rate decreases by another factor of [Figure omitted from source export] due to relativistic time dilation.13 The remaining [Figure omitted from source export] factor comes from the aberration of light, which makes the distant object appear larger than its physical size would suggest.13 When using flux density per unit frequency (AB magnitudes), the relation simplifies to dimming by a factor of [Figure omitted from source export].13

• Static Universe with Tired Light: In Zwicky’s tired light model, the redshift is not caused by metric expansion.14 Instead, photons lose energy exponentially through interactions with the "resistance of space" over distance [Figure omitted from source export] 14:

[Figure omitted from source export] Because the universe is static, there is no cosmic time dilation or expansion-based angular distortion.13 Consequently, the surface brightness dims by only a single factor of [Figure omitted from source export] under standard VEGA magnitudes 13: [Figure omitted from source export] When measured in frequency-specific AB magnitudes, the surface brightness of a static universe remains completely constant, regardless of distance or redshift.13

Physical Falsification through Blurring

To show why the pure tired-light model is physically falsified, the engine simulates wave-particle scattering.14 If the energy loss in a tired light model were caused by physical scattering (such as the Compton or Raman effects) with intergalactic dust or plasma, the momentum transfer would deflect the photons' paths.14 The engine uses a particle diffusion simulation to demonstrate this effect.14 As photons propagate through a scattering medium, their directions scatter, causing distant point sources to appear blurry.14 The engine compares this simulated blurring with actual data from the Hubble Ultra Deep Field (HUDF).13 In the real universe, galaxies at redshifts [Figure omitted from source export] remain perfectly sharp, which rules out simple scattering as a mechanism for cosmic redshift.13

Gravitational Lensing, Dark Matter Halos, and Spacetime Emergence

At the intersection of general relativity and cosmology, the engine includes a module for simulating gravitational lensing and dark matter halo dynamics.16 This system models how light deflections can map invisible mass distributions in the universe.16

Background Light Source \* / \\ / \\ Light deflected by mass / O \\ \<--- Lens Center (Dark Matter Halo / NFW Profile) / \\ v v

Gravitational Lensing and Lensing Profiles

The lensing engine simulates how light rays from a background source (such as an elliptical core-Sérsic galaxy) are deflected by a foreground lens.16 Advanced users can configure several mathematical profiles for the lens 16:

• Singular Isothermal Sphere (SIS): This profile assumes a flat velocity dispersion, projecting a mass distribution that models typical galaxy-scale lenses.16
• Truncated Navarro-Frenk-White (tNFW) Profile: This profile models the density distribution of cold dark matter halos.16 It is parameterized by the halo scale radius ([Figure omitted from source export]), the truncation radius ([Figure omitted from source export]), and the concentration parameter ([Figure omitted from source export]).16

The simulation calculates the Einstein Radius ([Figure omitted from source export]) to determine where multiple images or Einstein arcs form.16 The engine's rendering panel uses a ray-tracing shader to compute these deflections.16 Beginners can drag the dark matter halo across the screen to observe how the background galaxy stretches and warps into arcs in real time.16

Dark Matter Halo Shapes and the Inertia Tensor

To analyze the shapes of dark matter structures, the advanced interface exposes the calculations for the halo shape inertia tensor.15 Dark matter halos are modeled as triaxial ellipsoids with principal semi-axes lengths of [Figure omitted from source export].15 The components of the shape inertia tensor ([Figure omitted from source export]) are computed from the spatial coordinates ([Figure omitted from source export]) of the halo's simulated particles 15: [Figure omitted from source export] Diagonalizing this tensor yields eigenvectors that define the orientations of the principal axes, while the eigenvalues determine the axial ratios [Figure omitted from source export] (minor-to-major) and [Figure omitted from source export] (semimajor-to-major).15 The engine uses these calculations to demonstrate structural differences between galactic scales and massive galaxy clusters.15

By adjusting the telescope's angular resolution, users can see how resolving power affects our ability to observe these dark matter structures.30 Improving the resolution from [Figure omitted from source export] to [Figure omitted from source export] can increase the detection of faint, dwarf satellite galaxies by up to six times, helping map the low-mass limits of dark matter halos.30

The Radial Acceleration Relation (RAR)

To explore alternative gravity models, the engine includes a module for simulating the Radial Acceleration Relation (RAR).17 The RAR connects the observed acceleration ([Figure omitted from source export]) derived from rotation curves with the acceleration calculated purely from visible baryonic mass ([Figure omitted from source export]) 17: [Figure omitted from source export] where [Figure omitted from source export] is a fundamental acceleration scale.17 At high accelerations ([Figure omitted from source export]), the relation is one-to-one, meaning baryonic matter accounts for all the observed dynamics.17 At low accelerations ([Figure omitted from source export]), the observed acceleration flattens to a power-law slope of approximately [Figure omitted from source export], demonstrating the classic flat rotation curves discovered by Vera Rubin and Albert Bosma.17 Users can toggle between standard Newtonian gravity with dark matter halos and modified gravity models (such as MOND) to see how each model matches observed galaxy rotation curves.17

Observed Acceleration (g\_obs) ^ | / (1:1 Relation, Baryon-Dominated) | / | / | / | / | \_.-' \<--- Acceleration Scale g\_0 | \_.-' | \_.-' (Slope \~ 0.5, Dark Matter / MOND Regime) | \_.-' \+----------------------------------------------------\> Baryonic Acceleration (g\_bar)

Atemporal Graph Projections and Spacetime Emergence

To align with the theoretical physics essays published on the ArcSecs domain, the platform includes a quantum cosmology sandbox.4 This module explores the concept that physical spacetime is not a fundamental background.5 Instead, spacetime can emerge from a non-spatiotemporal Hilbert space ([Figure omitted from source export]) composed of tensor products of smaller spaces 5: [Figure omitted from source export]

\- Defined by tensor product states: H\_i ⊗ H\_j \- Quantum mutual information defines network connectivity | v \[ Atemporal Entanglement Graph G=(V,E) \] \- Nodes (V) represent physical qubits (e.g., spin, angular momentum) \- Edges (E) represent entanglement strengths | v (Dynamic clustering & Spring-mass layout)

\- Projections simulate standard 3D coordinate space \- Disruption of links manifests as gravity/curvatures

Quantum Entanglement and Emergent Geometry

In this sandbox, the traditional coordinate-based simulation window is replaced by an atemporal graph [Figure omitted from source export].31 Nodes ([Figure omitted from source export]) represent physical qubits, which are not defined by spatial coordinates but by quantum states like energy or angular momentum.5 Edges ([Figure omitted from source export]) represent the quantum entanglement or mutual information between these qubits.5 To make this concept understandable to beginners, the engine uses a spring-mass visualizer.5 Qubits with high entanglement are pulled closer together by strong spring forces, while unentangled qubits drift apart.5 As users draw entanglement links between nodes, the graph dynamically clusters into recognizable shapes.5 This clustering visually demonstrates how a continuous, multi-dimensional space can emerge from non-spatial quantum information.5

Quantum Error Correction and Gravity

For advanced users, this module simulates spacetime as a quantum error-correcting code.5 In this framework, stable macroscopic "logical qubits" are constructed from entangled networks of "physical qubits".5 The engine lets users simulate local perturbations on the physical qubits.5 If the entanglement network is robust, the logical spacetime metric remains stable, demonstrating error tolerance.5 Advanced users can also explore models where dark matter is simulated as a projection effect.31 In these models, what we observe as dark matter is represented as the gravitational "shadow" of structures in neighboring planes of the atemporal graph, projected into our local spacetime coordinate system.31

Technical Recommendations for the ArcSecs Engine

To successfully implement these dual-tier physics and cosmological modules, the development of the ArcSecs platform should focus on several key areas:

• Implement a Fixed-Update/Multi-Threaded Loop: To prevent high-velocity bodies from clipping through boundaries, the physics engine should run at a high, deterministic frequency (such as [Figure omitted from source export] or [Figure omitted from source export]) on a background Web Worker.3 The rendering pipeline on the main browser thread should run independently, interpolating positions between physics steps to match the screen's refresh rate.6
• Use Shader-Based Ray-Tracing for Lensing and Wave Optics: Calculating gravitational lensing and light deflection across millions of pixels is computationally heavy.16 These calculations should be offloaded to WebGL Fragment Shaders.2 This allows the platform to render complex cosmological phenomena, like Einstein rings, at fluid frame rates.16
• Build Context-Aware Mathematical Help Overlays: The engine's user interface should dynamically adapt to user actions.6 When a user selects a spring constraint, the platform should display the spring's physical parameters alongside its equations.20 Clicking on these equations should open an interactive panel where advanced users can directly modify the solver's math.6
• Connect Theoretical Modules to Real Astronomical Datasets: To make the advanced modules more engaging, the engine should let users load actual cosmological data.26 For example, users should be able to load galaxy rotation curves from the SPARC dataset to test gravity models, or import redshift-distance data from the Pantheon+ supernova dataset to analyze cosmic expansion.26

By combining high-performance web engineering with interactive, educational visual diagnostics, the ArcSecs engine can serve as a powerful tool for a wide audience.1 It can provide a clear and intuitive introduction to physics for beginners while offering a rigorous, mathematically detailed simulation sandbox for advanced researchers.6

Works cited

1. Physics Engine in Odin from Scratch, Part I \- Marian Pekár | Blog, accessed May 28, 2026, https://marianpekar.com/blog/physics-engine-in-odin-from-scratch-part-i
2. 2D C++ Physics Engine \- Fabian Huber, accessed May 28, 2026, https://fabianhbr.ch/projects/physics-engine
3. Adding physics to web components \- DEV Community, accessed May 28, 2026, https://dev.to/eerk/adding-physics-to-web-components-4kh2
4. Plato and Nietzsche \- Leiter Reports, accessed May 28, 2026, https://leiterreports.com/2026/05/12/plato-and-nietzsche/
5. Spacetime does not exist \- Leiter Reports, accessed May 28, 2026, https://leiterreports.com/2026/04/23/spacetime-does-not-exist/
6. Springs demo \- p2-es physics engine, accessed May 28, 2026, https://p2-es.pmnd.rs/demos/springs.html
7. Re: parsecs and arcsecs \- UCLA Physics & Astronomy, accessed May 28, 2026, https://www.physics.ucla.edu/wwwboard/voh/fall97\_quarter/physics/3\_Huffman/messages/6.html
8. Angular diameter \- Wikipedia, accessed May 28, 2026, https://en.wikipedia.org/wiki/Angular\_diameter
9. Calculating the Distance to Nearby Stars: The Stellar Parallax, accessed May 28, 2026, https://aaa.org/2023/07/01/calculating-the-distance-to-nearby-stars-the-stellar-parallax/
10. RomanPPP/TypeScript-Physics-Engine \- GitHub, accessed May 28, 2026, https://github.com/RomanPPP/TypeScript-Physics-Engine
11. Angular resolution \- Wikipedia, accessed May 28, 2026, https://en.wikipedia.org/wiki/Angular\_resolution
12. Ast 401/Phy 580 Fall 2015 \- Lowell Observatory, accessed May 28, 2026, http://www2.lowell.edu/users/massey/6\_Telescopes.pdf
13. UV surface brightness of galaxies from the local universe to z \~ 5 \- ResearchGate, accessed May 28, 2026, https://www.researchgate.net/publication/262071666\_UV\_surface\_brightness\_of\_galaxies\_from\_the\_local\_universe\_to\_z\_5
14. Tired light \- Wikipedia, accessed May 28, 2026, https://en.wikipedia.org/wiki/Tired\_light
15. Subhaloes are anisotropically distributed and aligned with the smooth matter distribution of their host haloes \- Oxford Academic, accessed May 28, 2026, https://academic.oup.com/mnras/article/538/2/963/8030530
16. A forward-modelling method to infer the dark matter particle mass from strong gravitational lenses \- Oxford Academic, accessed May 28, 2026, https://academic.oup.com/mnras/article/511/2/3046/6516982
17. MIGHTEE-HI: The radial acceleration relation with resolved stellar mass measurements, accessed May 28, 2026, https://arxiv.org/html/2504.20857v1
18. Physics Engine 13x Faster than Matter.js : r/typescript \- Reddit, accessed May 28, 2026, https://www.reddit.com/r/typescript/comments/14ogysu/physics\_engine\_13x\_faster\_than\_matterjs/
19. Javascript/Typescript Physics Engines \- HTML5 Game Devs Forum, accessed May 28, 2026, https://www.html5gamedevs.com/topic/26608-javascripttypescript-physics-engines/
20. 15-462 Project 5: Simple Physics Engine, accessed May 28, 2026, https://www.cs.cmu.edu/afs/cs/academic/class/15462-s12/www/project/p5.pdf
21. Parallax, accessed May 28, 2026, https://ircamera.as.arizona.edu/NatSci102/NatSci/text/parallax.htm
22. Parsec confusion \- astronomy \- Physics Stack Exchange, accessed May 28, 2026, https://physics.stackexchange.com/questions/762253/parsec-confusion
23. How do I apply specific astronomy concepts I have learned to calculations? | Wyzant Ask An Expert, accessed May 28, 2026, https://www.wyzant.com/resources/answers/952462/how-do-i-apply-specific-astronomy-concepts-i-have-learned-to-calculations
24. MUltiplexed Survey Telescope: Perspectives for Large-Scale Structure Cosmology in the Era of Stage-V Spectroscopic Survey \- arXiv, accessed May 28, 2026, https://arxiv.org/html/2411.07970v3
25. The Galileo of Palomar \- Halton Arp, accessed May 28, 2026, http://haltonarp.com/inc/memorial/TheGalileoOfPalomar.pdf
26. JWST early Universe observations and ΛCDM cosmology | Monthly Notices of the Royal Astronomical Society | Oxford Academic, accessed May 28, 2026, https://academic.oup.com/mnras/article/524/3/3385/7221343?login=false
27. Is "Hubble-Independent Distance Calculator to Cosmological Objects" article a rebranding of Tired Light Model? | ResearchGate, accessed May 28, 2026, https://www.researchgate.net/post/Is\_Hubble-Independent\_Distance\_Calculator\_to\_Cosmological\_Objects\_article\_a\_rebranding\_of\_Tired\_Light\_Model
28. AaS\! 267: Is the Universe Older than We Think? \- Paul M. Sutter, accessed May 28, 2026, https://www.pmsutter.com/shows/askaspaceman-archive/2026/03/03/aas-267-is-the-universe-older-than-we-think
29. Testing CCC+TL Cosmology with Galaxy Rotation Curves \- MDPI, accessed May 28, 2026, https://www.mdpi.com/2075-4434/13/5/108
30. Hunting for the faintest galaxies | astrobites, accessed May 28, 2026, https://astrobites.org/2017/11/29/hunting-for-the-faintest-galaxies/
31. What if what we call “dark” components are not new particles but inter projection effects: shadows of massive structures in neighbouring planes of the atemporal graph. : r/HypotheticalPhysics \- Reddit, accessed May 28, 2026, https://www.reddit.com/r/HypotheticalPhysics/comments/1sosr6c/what\_if\_what\_we\_call\_dark\_components\_are\_not\_new/