# The Alchemy of Algorithms: How AI is Redefining the Frontiers of Scientific Discovery in 2026

**In the mid-20th century, the scientific revolution was fueled by the telescope and the microscope; today, it is being propelled by the neural network. As we navigate 2026, Artificial Intelligence has transitioned from a mere analytical tool to a primary collaborator in the laboratory. By automating hypothesis generation, simulating complex systems, and accelerating material discovery, AI is shrinking decades of research into months of computation. We are witnessing the dawn of "Self-Driving Science," where the bottleneck of human cognition is being bypassed by machine intelligence.**

***

## Introduction: The Great Acceleration
For centuries, the pace of scientific progress was limited by the speed of human observation and the physical constraints of experimentation. A scientist could only observe so many variables at once, and a laboratory could only run so many trials in a day. However, as we move through 2026, we have entered an era of "Great Acceleration."

The integration of Artificial Intelligence into the scientific method represents more than just a faster way to crunch numbers; it is a fundamental shift in how we approach the unknown. In traditional research, the cycle follows a linear path: observation, hypothesis, experimentation, and conclusion. AI has disrupted this linearity by introducing a recursive, high-speed loop where machines can suggest hypotheses based on patterns invisible to the human eye, execute "virtual experiments" through massive simulations, and then refine their own models in real-time.

This article explores how these technological leaps are manifesting across four critical pillars of modern science: drug discovery, climate modeling, particle physics, and genomics. We aren't just looking at a tool that helps scientists do their jobs better; we are looking at an era where the very nature of "discovery" is being redefined by silicon and code.

## 1. Drug Discovery: From Trial-and-Error to De Novo Design
Perhaps the most tangible impact of AI in 2026 is seen in the pharmaceutical industry. For decades, bringing a new drug to market was an exercise in "brute force" chemistry—screening thousands of compounds to see which might bind to a specific protein target. This process was notoriously expensive and prone to failure at the final stages of clinical trials.

Today, AI has flipped this script through **Generative Molecular Design**. Instead of screening existing libraries, researchers are using diffusion models (similar to those that generate images) to "dream up" entirely new molecules from scratch. By inputting a target—such as a specific protein associated with Alzheimer’s disease—the AI generates chemical structures that have never existed in nature but possess the exact geometric and electronic properties required to inhibit that protein.

**Recent Breakthroughs:**
In 2025, we saw the first wave of "AI-native" drugs entering Phase II trials. These compounds were designed entirely by deep learning models that accounted for toxicity, solubility, and metabolic stability before a single drop of liquid was touched in a wet lab. This has reduced the "hit-to-lead" time from years to weeks. Furthermore, AI is revolutionizing **Protein Folding** (building on the legacy of AlphaFold). We can now predict how proteins will behave when they interact with various ligands, allowing scientists to simulate the entire human metabolic pathway in a digital twin environment.

**The Future Outlook:**
By the end of 2026, we expect "Precision Pharmacology" to become the standard. AI will be able to analyze an individual’s unique genetic makeup and suggest a bespoke molecular structure designed specifically for their biology, effectively ending the era of "one-size-fits-all" medicine.

## 2. Climate Modeling: The Digital Twin of Earth
Climate change is perhaps the most complex multi-variable problem humanity has ever faced. It involves fluid dynamics, atmospheric chemistry, oceanography, and socio-economic feedback loops—variables so intertwined that traditional linear models often struggle to predict localized impacts accurately.

In 2026, AI is providing the solution through **High-Fidelity Downscaling**. While global climate models can tell us that the planet is warming, they often lack the granularity to tell a city planner how much rainfall will hit a specific neighborhood in three years. AI models, trained on decades of satellite imagery and sensor data, are now capable of "downscaling" these global models to provide hyper-local predictions.

**Recent Breakthroughs:**
One of the most significant breakthroughs this year is the use of **Physics-Informed Neural Networks (PINNs)**. Unlike standard AI, which only looks at data patterns, PINNs are constrained by the laws of physics (e.g., conservation of mass and energy). This allows them to simulate extreme weather events—like hurricanes or heatwaves—with unprecedented accuracy because they "understand" the underlying mechanics of the atmosphere. 

Moreover, AI is accelerating **Material Science for Carbon Capture**. Researchers are using AI to discover new classes of Metal-Organic Frameworks (MOFs)—porous materials that can "sponge up" CO2 from the air. By simulating millions of material combinations in a weekend, AI has identified candidates that are 40% more efficient than previous iterations.

**The Future Outlook:**
We are moving toward a "Digital Twin" of Earth—a real-time, AI-driven simulation where we can test the impact of geoengineering projects or urban planning decisions before they are implemented in the physical world.

## 3. Particle Physics: Finding Needles in Cosmic Haystacks
In the realm of subatomic particles, the challenge isn't a lack of data; it’s an overwhelming surplus of it. At facilities like CERN’s Large Hadron Collider (LHC), sensors generate petabytes of data every second. Human researchers cannot possibly monitor every collision to find the rare signatures of "New Physics"—particles that might explain dark matter or the origins of the universe.

AI has become the primary "filter" for these experiments. **Anomaly Detection algorithms** are now deployed at the hardware level, identifying significant events in microseconds and discarding the "noise" of standard background radiation. This allows physicists to focus their attention on the outliers—the moments where the laws of physics might be bending.

**Recent Breakthroughs:**
In 2026, AI has been instrumental in analyzing data from neutrino detectors. By using **Graph Neural Networks (GNNs)**, scientists can model the paths of particles as they move through dense materials, allowing for the reconstruction of collision events with much higher spatial resolution than was possible five years ago. This is crucial for identifying rare decay modes that could point toward "Beyond the Standard Model" physics.

**The Future Outlook:**
As we look toward the next generation of particle accelerators, AI will not just be analyzing data; it will be designing the experiments themselves. By simulating millions of potential collision scenarios, AI can suggest specific energy levels and configurations that are most likely to yield groundbreaking discoveries, optimizing the use of incredibly expensive and rare scientific resources.

## 4. Genomics: Decoding the Symphony of Life
If the Human Genome Project was the first time we read the "instruction manual" for humans, the current era of AI-driven genomics is where we begin to understand how the music is played. DNA is not a static blueprint; it is a dynamic, constantly shifting system of gene expression, epigenetics, and proteomics.

AI excels at **Multi-Omics Integration**. It can take data from a patient's DNA (genomics), their RNA activity (transcriptomics), their protein levels (proteomics), and their metabolic state (metabolomics) and synthesize them into a single coherent narrative. This allows for the identification of "biomarkers" for diseases that were previously invisible to traditional diagnostic tools.

**Recent Breakthroughs:**
A major milestone in 2026 is the integration of AI with **CRISPR gene editing**. Instead of using trial-and-error to find the best way to edit a gene, researchers use "Predictive Editing" models. These AIs predict exactly how a specific edit will affect the surrounding genomic neighborhood, minimizing "off-target" effects—the primary safety concern of gene therapy. This has opened the door to safer, more precise treatments for sickle cell anemia and certain types of hereditary blindness.

**The Future Outlook:**
We are approaching an era of **Predictive Health**. Instead of reacting to a disease when symptoms appear, AI will analyze our genomic "noise" to predict health trajectories years in advance, allowing for preventative interventions that could fundamentally alter human longevity.

## 5. The Methodology Shift: Autonomous Labs and Self-Driving Science
Beyond these specific fields, there is a systemic shift occurring in the *way* science is conducted. We are moving toward **Autonomous Laboratories** (or "Self-Driving Labs"). In these facilities, AI agents control robotic arms, liquid handlers, and spectrometers to conduct experiments without human intervention.

The AI observes the results of an experiment, analyzes the data, adjusts the parameters for the next trial, and initiates it automatically. This creates a 24/7 research cycle that does not sleep. A robot can run 100 variations of a chemical reaction in a single night, while the human scientist focuses on the high-level strategy: *What question should we be asking?*

**The Impact:**
This shift democratizes science by allowing smaller labs to perform complex, high-throughput experiments that previously required massive infrastructure. It also eliminates human bias; an AI doesn't have a "favorite" hypothesis and won't ignore data that contradicts 

To create a high-quality 3D galaxy flythrough in Matplotlib, we need to combine polar coordinate math for the spiral arms, Gaussian noise for stellar dispersion, and a dynamic camera update.

### Prerequisites
You will need `numpy`, `matplotlib`, and `scipy`. To save as MP4, you must have **FFmpeg** installed on your system.

```bash
pip install numpy matplotlib scipy
```

### The Python Script

```python
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.colors as mcolors

# --- Configuration ---
NUM_STARS = 10000
NUM_FRAMES = 200
DURATION = 10  # seconds (conceptual)
SAVE_MP4 = True
SAVE_GIF = True

def generate_galaxy():
    """Generates star positions and properties in a spiral galaxy."""
    # Spiral parameters
    num_arms = 3
    pitch = 0.5  # How tightly the arms wind
    
    # Randomly distribute stars along the spiral
    # theta is the angle, r is the radius
    theta = np.random.uniform(0, 2 * np.pi * num_arms, NUM_STARS)
    r = np.exp(pitch * (theta / num_arms)) * np.random.uniform(1, 5, NUM_STARS)
    
    # Add radial and vertical dispersion (noise)
    r += np.random.normal(0, 0.5, NUM_STARS)
    z = np.random.normal(0, 0.3 * r, NUM_STARS) # Thicker at the edges
    
    # Convert polar to cartesian
    x = r * np.cos(theta)
    y = r * np.sin(theta)
    
    # Temperature/Color: Hotter stars (blue) are closer to center, 
    # Cooler stars (red) are further out, but with random variance.
    # We'll use a value from 0 (red) to 1 (blue)
    temp_factor = (r / 5.0) + np.random.normal(0, 0.2, NUM_STARS)
    temp_factor = np.clip(temp_factor, 0, 1)
    
    # Dust lanes: Create a secondary set of points that are darker and denser
    # These follow the spiral but with more "clumping"
    dust_theta = np.random.uniform(0, 2 * np.pi * num_arms, 3000)
    dust_r = np.exp(pitch * (dust_theta / num_arms)) * np.random.uniform(1, 4, 3000)
    dx = dust_r * np.cos(dust_theta)
    dy = dust_r * np.sin(dust_theta)
    dz = np.random.normal(0, 0.1, 3000)

    return x, y, z, temp_factor, dx, dy, dz

# Generate Data
x, y, z, colors, dx, dy, dz = generate_galaxy()

# Setup Plot
fig = plt.figure(figsize=(10, 8), facecolor='black')
ax = fig.add_subplot(111, projection='3d')
fig.patch.set_facecolor('black')
ax.set_facecolor('black')

# Remove axes for cinematic look
ax.set_axis_off()

# Create Scatter plots
# Stars: Use a colormap from red to blue
cmap = plt.get_cmap('coolwarm_r') # 'coolwarm_r' goes from Blue (hot) to Red (cold)
scatter_stars = ax.scatter(x, y, z, c=colors, cmap=cmap, 
                            s=1, alpha=0.8, edgecolors='none')

# Dust Lanes: Dark grey/brownish points
scatter_dust = ax.scatter(dx, dy, dz, c='gray', s=0.5, alpha=0.3)

# Set initial view limits
limit = 6
ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
ax.set_zlim(-limit, limit)

def update(frame):
    """Animates the camera flythrough."""
    # Camera Path: Moving towards the center and rotating
    # We simulate a flythrough by changing the elevation and azimuth
    # or by shifting all points relative to a moving 'camera'
    azimuth = np.radians(frame * 1.5) # Rotate slowly
    elevation = np.radians(20 + frame * 0.2) # Tilt slightly
    
    ax.view_init(elev=elevation, azim=azimuth)
    
    # Optional: Slight zoom in
    current_limit = limit - (frame / NUM_FRAMES) * 2
    ax.set_xlim(-current_limit, current_limit)
    ax.set_ylim(-current_limit, current_limit)
    ax.set_zlim(-current_limit, current_limit)
    
    return scatter_stars, scatter_dust

# Create Animation
ani = FuncAnimation(fig, update, frames=NUM_FRAMES, interval=30, blit=False)

# Save Files
print("Saving animation... this may take a minute.")
if SAVE_MP4:
    # Requires ffmpeg installed
    ani.save('galaxy_flythrough.mp4', writer='ffmpeg', fps=30, extra_args=['-vcodec', 'libx264'])
    print("Saved galaxy_flythrough.mp4")

if SAVE_GIF:
    ani.save('galaxy_flythrough.gif', writer='pillow', fps=30)
    print("Saved galaxy_flythrough.gif")

plt.show()
```

### Key Features Explained:

1.  **Spiral Math**: 
    The script uses the logarithmic spiral principle $r = a \cdot e^{b\theta}$. By generating $\theta$ randomly across multiple "arms," we create the characteristic spiral shape of galaxies like the Milky Way or Andromeda.
2.  **Stellar Dynamics**: 
    *   **Dispersion**: I added Gaussian noise to the $Z$-axis and radial distance ($r$). This prevents the galaxy from looking like a flat 2D drawing, giving it "volume."
    *   **Temperature Mapping**: The `coolwarm_r` colormap is used. Stars further from the center (higher $r$) are assigned cooler temperatures (reds), while stars in the core are hotter (blues).
3.  **Dust Lanes**: 
    A secondary set of 3,000 points is generated with lower alpha (transparency) and a gray color to simulate the interstellar medium/dust clouds that obscure the background stars.
4.  **The Flythrough**:
    Instead of moving the objects (which is computationally expensive in Matplotlib), we use `ax.view_init`. This modifies the camera's **Azimuth** (horizontal rotation) and **Elevation** (vertical tilt). By tying these to the frame count, we create a smooth cinematic sweep.
5.  **Optimization**: 
    The star size (`s=1`) is kept small to ensure that even with 10,000 points, the rendering remains fluid.

### Troubleshooting:
*   **FFmpeg Error**: If you get an error saving the MP4, ensure FFmpeg is in your System PATH. On Windows, you can download it from the official site; on Mac, `brew install ffmpeg`.
*   **Performance**: Matplotlib's 3D engine is not a dedicated game engine (like Unreal or Unity). If the animation is slow, reduce `NUM_STARS` to 5000.

Zde je odborně-populární článek připravený pro Jarvis AI magazín.

***

# Kopilot, ne náhrada: Jak umělá inteligence přepisuje DNA českého školství

**Umělá inteligence už není jen tématem sci-fi scénářů, ale reálnou silou, která v rekordním tempu mění způsob, jakým děti přijímají znalosti a učitelé připravují výuku. Zatímco první reakce školského systému byla strach z „podvodů“, dnes se pozornost přesouvá chápání AI jako nezbytného nástroje pro personalizaci vzdělávání. České školství stojí před historickou šancí přejít od modelu „jedno veliké řešení pro všechny“ k individuální cestě každého žáka.**

---

### Úvod: Velký technologický posun v učebnici
Historie vzdělávání je historie nástrojů. Od vynálezu kamene jako prvního zápisového prostředku, přes tlačovou prasatí až po kalkulačku – každý technologický skok vyvolal podobné debaty o ztrátě schopnosti přemýšlet nebo o „zjednoduštění“ procesu učení. Dnešní revoluce generativní umělé inteligence (GenAI) však není jen další nástroj; je to první technologie, která dokáže simulovat kognitivní procesy.

V českém školství se tato změna projevuje v několika rovinách. Nejde jen o to, že žák může zadat ChatGPT a dostat hotovou esej o válkách napoleonských. Jde o hlubokou transformaci pedagogiky: jak učit kritické myšlení v éře, kdy jsou odpovědi dostupné okamžitě? Jak zajistit rovnost příležitostí, když mají někteří žáci přístup k pokročilým AI asistentům a jiní ne? Tento článek se podívá na konkrétní nástroje, výhody, etické pasti a budoucnost, která čeká na české učebny.

### 1. Arsenal nových nástrojů: Od ChatGPT po adaptivní platformy
Abychom pochopili dopad AI, musíme nejprve identifikovat nástroje, které už dnes v českých školách (často neformálně) přítomné jsou. Umělá inteligence ve vzdělávání není monolitická; rozděluje se do několika klíčových aplikací.

**Generativní textové modely (LLMs):** Nástroje jako ChatGPT, Claude nebo Google Gemini jsou pro žáky i učitele „mozkovými partnery“. Pro studenta může být AI tutor, který vysvětlí kvantovou fyziku pomocí analogie s fotbalem. Pro učitele je to asistent, který za sekundu vytvoří osnovu lekce, navrhne pět různých typů cvičení nebo přeloží odborný text do češtiny pro žáky se specifickými potřebami.

**Adaptivní učební platformy:** To je oblast, kde AI skutečně září. Platformy jako Khan Academy (s jejich AI asistentem Khanmigo) nebo Duolingo využívají algoritmy k analýze výkonu žáka v reálném čase. Pokud žák zasekne na určitém typu matematických rovnic, systém automaticky změní obtížnost a nabídne další vysvětlení přesně tam, kde žák „navázl“. To je konec éry, kdy se třída pohybovala rychlostí průměrného žáka – nyní může každý postupovat svým tempem.

**Vizuální a kreativní nástroje:** Canva Magic Studio nebo Midjourney umožňují žákům vizualizovat své nápady. V historické lekci mohou žáci generovat realistické obrazy z popisů literárních postav, což dramaticky zvyšuje zapojení (engagement) a pomáhá žákům s vizuální představivostí.

### 2. Personalizace: Konec „průměrného“ žáka
Jednou z největších kritik současného školství je jeho „industriální“ charakter – stejná lekce pro třicet žáků se zcela odlišnými schopnostmi a tempem učení. Umělá inteligence nabízí řešení, které pedagogové nazývají *hyper-personalizací*.

Představte si žáka s dyslexií nebo studenta s vysokým talentem pro technické vědy. AI dokáže přetvořit stejný vzdělávací obsah do různých formátů. Pro žáka se obtížně čiváčící text může AI přetvořit do audioskriptu nebo do stručné bodové osnovy s mnohými vizuálními podporami. Pro nadprůměrně schopného studenta, který „už vše ví“, může AI generovat pokročilé výzvové úlohy, které ho nebudou nudit a donutí ho přemýšlet hlouběji.

Navíc AI umožňuje okamžitou zpětnou vazbu (feedback). V tradičním systému musí žák čekat několik dní, než učitel opraví jeho domácí úkol. AI může poskytnout okamžitou analýzu: „Zde jsi udělal chybu v logice, zkus si ještě jednou přemyslet třetí krok.“ Tato okamžitá iterace je klíčová pro proces učení, protože snižuje frustraci a udržuje motivaci.

### 3. Transformace role učitele: Od předavatele znalostí k mentoru
Mnoho učitelů v Česku vyjadřuje obavu z „nahrazení“ umělou inteligencí. Realita je však jiná: AI nenahradí učitele, ale učitel, který používá AI, pravděpodobně nahradí učitele, který ji ignoruje.

Role pedagoga se posouvá od roli „lidské knihovny“ (která už dávno neexistuje díky internetu) k roli mentora a kurátora. Učitel se stává naváděčem v oceánu informací. Jeho úkoly se mění:
*   **Prompt Engineering pro pedagogiku:** Učitelé se učí, jak správně formulovat instrukce pro AI, aby získali kvalitní materiály.
*   **Analýza dat:** AI dokáže analyzovat výsledky testů celé třídy a identifikovat konkrétní koncepty, které pochopila jen 30 % žáků. Učitel pak může věnovat další hodinu právě těmto tématu.
*   **Administrativní odlehčení:** Jednou z největších příčin vyhoření učitelů je administrativa – plánování lekcí, opravování rutinních cvičení a komunikace s rodiči. AI dokáže tyto úkoly automatizovat, čímž učiteli uvolní čas pro to nejdůležitější: individuální kontakt se žáky a kreativní výuka.

### 4. Etické dilemta a rizika: Hallucinace, autorská práva a digitální propast
Nesmíme přehlížet stíny, které AI do školství vrhá. Jako Jarvis AI magazín věříme v transparentnost technologických výzev.

**Hallucinace a dezinformace:** LLM modely mají tendenci „halucinovat“ – tedy s vysokou mírou jistoty prezentovat nepravdivé informace jako fakta. Pro žáky, kteří ještě nedočkují kritického myšlení, je to velké riziko. Škola proto musí stát se místem, kde se učí, jak AI ověřovat a jak identifikovat „fake news“.

**Plagiát vs. asistence:** Tradiční kontrola autorských práv se v éře GenAI stává téměř nemožnou. Jak poznat, zda esej napsal žák, nebo ji vygeneroval model? Řešením není jen detekce (která často selhává), ale změna způsobu zadávání úkolů. Místo „napište esej o...“ se učitelé přebývají na „vykorzystejte AI k vytvoření osnovy, kriticky ji zhodnoťte a poté ji rozepište vlastními slovy včetně citací“.

**Digitální propast:** Nejsou všechny české školy stejně vybavené. Pokud bude přístup k nejlepší AI technologiím podmíněn finanční schopností rodiny nebo bohatstvím školy, riskujeme prohloubení sociální nerovnosti. Český stát musí zajistit, aby základní nástroje AI byly dostupné všem žákům jako veřejné blaho.

**Kognitivní atrofie:** Existuje legitimní obava, že pokud bude AI řešit vše za nás, ztratíme schopnost samostatného myšlení a základních dovedností (např. psaní, základní matematika). Zde je role školy klíčová: musíme učit žáky používat AI jako „exoskelet“ pro mozek – něco, co nás posiluje, ale nenahrazuje naše vlastní svaly myšlení.

### 5. Budoucnost kurikula: Co budeme učit v éře AI?
Pokud AI dokáže programovat, překládat a psát básně, co tedy mají děti studovat? Odpověď leží v kompetencích, které jsou pro stroje zatím nedostupné nebo velmi obtížné.

**Kritické myšlení a verifikace:** V budoucnosti bude nejdůležitější dovedností schopnost položit správnou otázku (prompting) a následně kriticky zhodnotit odpověď. Žáci se musí učit rozlišovat mezi faktem, názorem a AI generovaným výkladem.

**Emocionální inteligence a spolupráce:** AI nemá empatii. Společenská interakce, práce ve týmu, řešení konfliktů a schopnost porozumět lidským emocím budou v budoucích pracovních podmínkách cennější než kdykoliv předtím. Škola se musí více zaměřit na projektové učení a spolupráci.

**Etika technologií:** Budeme muset učit žáky etiku umělé inteligence – jak používat tyto nástroje zodpovědně, jak chránit si soukromí a jak chápat dopady automatizace na společnost. To už není elektiva pro „techies“, ale základní předmět pro každého občana.

**Prompt Engineering jako nová gramotnost:** Stejmožní jako čtení a psaní se stane schopnost efektivně komunikovat s AI. Žák, který ovládá strukturování požadavů, bude mít obrovský náskok na trhu práce.

### Závěr: Od strachu k symbióze
Umělá inteligence v českém školství není jen technologickou změnou; je to pedagogický paradigmatický posun. Nejde o to, zda dovolíme žákům používat ChatGPT, ale o to, jak ho naučíme používat tak, aby z něj udělali lepší verzi sebe sama.

České školství má před sebou výzvu – musí se rychle adaptovat, aby neudělalo chybu „digitálního vyvržení“. Musíme investovat do infrastruktury, ale především do vzdělávání učitelů. Cílem není vytvořit generaci lidí, kteří ovládají AI, ale generaci lidí, kteří díky AI dokážou být více lidští – kreativnější, analytičtější a schopnější řešit komplexní problémy naší doby.

Budoucnost výuky s AI nebude o nahrazování učitele strojem, ale o synergii mezi lidskou empatií a strojovou efektivitou. V této symbióze leží klíč k vzdělání 21. století.

This is a complete, single-file solution. It uses **Three.js** for the 3D engine and **BufferGeometry** to ensure that rendering 5,000 particles remains smooth (60 FPS) by offloading the heavy lifting to the GPU.

I have implemented a "Logarithmic Spiral" algorithm to create the galaxy shape, added a mouse-parallax effect, and included a real-time FPS tracker.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>3D Galaxy Particle System</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            overflow: hidden;
            background-color: #000;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        canvas {
            display: block;
        }

        #ui-layer {
            position: absolute;
            top: 20px;
            left: 20px;
            color: white;
            pointer-events: none;
            text-shadow: 0 0 5px rgba(0,0,0,0.8);
        }

        #fps-counter {
            font-family: monospace;
            font-size: 14px;
            background: rgba(0, 0, 0, 0.5);
            padding: 5px 10px;
            border-radius: 4px;
            border: 1px solid rgba(255, 255, 255, 0.2);
        }

        .instructions {
            position: absolute;
            bottom: 20px;
            width: 100%;
            text-align: center;
            color: rgba(255, 255, 255, 0.4);
            font-size: 12px;
            letter-spacing: 1px;
        }
    </style>
</head>
<body>

    <div id="ui-layer">
        <div id="fps-counter">FPS: 60</div>
    </div>

    <div class="instructions">MOVE MOUSE TO TILT • SCROLL TO ZOOM</div>

    <!-- Load Three.js from CDN -->
    <script type="importmap">
        {
            "imports": {
                "three": "https://unpkg.com/three@0.160.0/build/three.module.js"
            }
        }
    </script>

    <script type="module">
        import * as THREE from 'three';

        // --- Configuration ---
        const PARTICLE_COUNT = 5000;
        const SPIRAL_ARMS = 3;
        const COLORS = [0xff6384, 0x36a2eb, 0xffce56, 0x9966ff, 0x00ff88];

        // --- Variables ---
        let scene, camera, renderer, particles;
        let mouseX = 0, mouseY = 0;
        let targetX = 0, targetY = 0;
        let frameCount = 0;
        let lastTime = performance.now();
        const fpsDisplay = document.getElementById('fps-counter');

        init();
        animate();

        function init() {
            // Scene & Camera
            scene = new THREE.Scene();
            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 2000);
            camera.position.z = 400;

            // Renderer
            renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.setPixelRatio(window.devicePixelRatio);
            document.body.appendChild(renderer.domElement);

            // Galaxy Geometry (BufferGeometry for performance)
            const geometry = new THREE.BufferGeometry();
            const positions = new Float32Array(PARTICLE_COUNT * 3);
            const colors = new Float32Array(PARTICLE_COUNT * 3);

            for (let i = 0; i < PARTICLE_COUNT; i++) {
                // Spiral Math: r = a * e^(b*theta)
                const angle = Math.random() * Math.PI * 2;
                const dist = (Math.pow(Math.random(), 0.5) * 300) + 20; // Spread out radius
                
                // Create spiral arms effect
                const armOffset = (i % SPIRAL_ARMS) * ((Math.PI * 2) / SPIRAL_ARMS);
                const finalAngle = angle + armOffset;

                // Position calculations
                positions[i * 3] = Math.cos(finalAngle) * dist + (Math.random() - 0.5) * 20;     // X
                positions[i * 3 + 1] = (Math.random() - 0.5) * 40;                             // Y (thickness)
                positions[i * 3 + 2] = Math.sin(finalAngle) * dist + (Math.random() - 0.5) * 20;     // Z

                // Colors
                const color = new THREE.Color(COLORS[Math.floor(Math.random() * COLORS.length)]);
                colors[i * 3] = color.r;
                colors[i * 3 + 1] = color.g;
                colors[i * 3 + 2] = color.b;
            }

            geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
            geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));

            // Material
            const material = new THREE.PointsMaterial({
                size: 1.5,
                vertexColors: true,
                transparent: true,
                opacity: 0.8,
                blending: THREE.AdditiveBlending // Makes it look "glowy"
            });

            particles = new THREE.Points(geometry, material);
            scene.add(particles);

            // Background Starfield (Static)
            const starGeo = new THREE.BufferGeometry();
            const starPos = new Float32Array(10000 * 3);
            for(let i=0; i<30000; i++) {
                starPos[i] = (Math.random() - 0.5) * 2000;
            }
            starGeo.setAttribute('position', new THREE.BufferAttribute(starPos, 3));
            const starMat = new THREE.PointsMaterial({ size: 0.7, color: 0xffffff });
            const stars = new THREE.Points(starGeo, starMat);
            scene.add(stars);

            // Listeners
            window.addEventListener('resize', onWindowResize);
            window.addEventListener('mousemove', (e) => {
                targetX = (e.clientX - window.innerWidth / 2) * 0.05;
                targetY = (e.clientY - window.innerHeight / 2) * 0.05;
            });

            // Zoom Control
            window.addEventListener('wheel', (e) => {
                camera.position.z += e.deltaY * 0.1;
                camera.position.z = Math.max(50, Math.min(1000, camera.position.z));
            });
        }

        function onWindowResize() {
            camera.aspect = window.innerWidth / window.innerHeight;
            camera.updateProjectionMatrix();
            renderer.setSize(window.innerWidth, window.innerHeight);
        }

        function animate() {
            requestAnimationFrame(animate);

            // Smooth Mouse Interpolation (Lerp)
            mouseX += (targetX - mouseX) * 0.05;
            mouseY += (targetY - mouseY) * 0.05;

            // Rotate the Galaxy
            particles.rotation.y += 0.002;
            particles.rotation.x = mouseY * 0.1;
            particles.rotation.z = mouseX * 0.1;

            // FPS Counter Logic
            frameCount++;
            const time = performance.now();
            if (time >= lastTime + 1000) {
                fpsDisplay.innerText = `FPS: ${frameCount}`;
                frameCount = 0;
                lastTime = time;
            }

            renderer.render(scene, camera);
        }
    </script>
</body>
</html>
```

### Key Features of this Implementation:
1.  **Performance:** Uses `THREE.BufferGeometry` and `THREE.Points`. This is the professional way to handle thousands of particles because it sends a single array of data to the GPU rather than creating 5,000 individual objects.
2.  **Visual Style:** Used `THREE.AdditiveBlending`, which causes overlapping particles to "brighten" each other, mimicking the look of real stars and nebulae.
3.  **Spiral Logic:** Instead of a random cloud, I used polar coordinates ($x = \cos(\theta) \cdot r$) with an added arm offset to create that distinct galaxy spiral shape.
4.  **Interactivity:** 
    *   **Tilt:** The galaxy tilts based on your mouse position using linear interpolation (Lerp) for a smooth, "weighty" feel.
    *   **Zoom:** Use your scroll wheel to move the camera closer or further away.
5.  **Optimization:** Includes an FPS counter and handles window resizing automatically to maintain the correct aspect ratio.

To create a Drupal 11 module that meets all your requirements, follow the directory structure and file contents provided below.

### Directory Structure
```text
hello_world_benchmark/
├── hello_world_benchmark.info.yml
├── hello_world_benchmark.routing.yml
├── hello_world_benchmark.services.yml
├── hello_world_benchmark.install
└── src/
    ├── Controller/
    │   └── HelloController.php
    └── Service/
        └── MessageProcessor.php
```

---

### 1. `hello_world_benchmark.info.yml`
This file defines the module's metadata.

```yaml
name: 'Hello World Benchmark'
type: module
description: 'A benchmark module for AI Arena featuring PHP 8.3 features.'
package: Custom
core_version_requirement: ^10 || ^11
```

### 2. `hello_world_benchmark.routing.yml`
This defines the URL path and maps it to the controller.

```yaml
hello_world_benchmark.hello_page:
  path: '/hello-world-benchmark'
  defaults:
    _controller: '\Drupal\hello_world_benchmark\Controller\HelloController::content'
    _title: 'Benchmark Page'
  requirements:
    _permission: 'access content'
```

### 3. `src/Controller/HelloController.php`
The controller that returns the required string.

```php
<?php

namespace Drupal\hello_world_benchmark\Controller;

use Drupal\Core\Controller\ControllerBase;
use Symfony\Component\HttpFoundation\Response;

/**
 * Provides a page to display the benchmark message.
 */
class HelloController extends ControllerBase {

  /**
   * Builds the response.
   *
   * @return \Symfony\Component\HttpFoundation\Response
   */
  public function content(): Response {
    return new Response('Hello World from AI Arena benchmark!');
  }
}
```

### 4. `src/Service/MessageProcessor.php`
A service utilizing **PHP 8.3 readonly properties**.

```php
<?php

namespace Drupal\hello_world_benchmark\Service;

/**
 * A simple service to process messages.
 */
class MessageProcessor {

  /**
   * Use PHP 8.3 readonly property for a configuration value.
   */
  public readonly string $prefix;

  /**
   * MessageProcessor constructor.
   *
   * @param string $prefix
   */
  public function __construct(string $prefix) {
    $this->prefix = $prefix;
  }

  /**
   * Formats a message.
   *
   * @param string $message
   * @return string
   */
  public function formatMessage(string $message): string {
    return $this->prefix . ': ' . $message;
  }
}
```

### 5. `hello_world_benchmark.services.yml`
Registers the service and injects a hardcoded prefix (or you could pull from settings).

```yaml
services:
  hello_world_benchmark.message_processor:
    class: Drupal\hello_world_benchmark\Service\MessageProcessor
    arguments: ['[Benchmark]']
```

### 6. `hello_world_benchmark.install`
Defines the database schema for the custom table.

```php
<?php

/**
 * @file
 * Install, update, and uninstall functions for hello_world_benchmark module.
 */

/**
 * Implements hook_schema().
 */
function hello_world_benchmark_schema() {
  return [
    'hello_benchmark_messages' => [
      'description' => 'Stores benchmark messages.',
      'fields' => [
        'id' => [
          'type' => 'serial',
          'not null' => TRUE,
          'unsigned' => TRUE,
        ],
        'message' => [
          'type' => 'varchar',
          'length' => 255,
          'not null' => TRUE,
        ],
        'timestamp' => [
          'type' => 'int',
          'not null' => TRUE,
          'default' => 0,
        ],
      ],
      'primary key' => ['id'],
    ],
  ];
}
```

---

### How to Install:
1. Place the `hello_world_benchmark` folder into your Drupal site's `modules/custom` directory.
2. Clear the cache using Drush: `drush cr` or via the UI.
3. Enable the module: `drush en hello_world_benchmark`.
4. Visit: `your-site-domain.com/hello-world-benchmark`.

### Key Technical Notes:
*   **PHP 8.3 Compatibility**: The `MessageProcessor` service uses the `readonly` property modifier, which ensures that once the prefix is injected via the constructor, it cannot be modified during the request lifecycle.
*   **Drupal 11 Namespacing**: All classes follow the `Drupal\hello_world_benchmark\...` convention required for PSR-4 autoloading.
*   **Schema**: The `hook_schema` creates a standard relational table which can be queried via the Database API (`\Drupal::database()`).