Inspiration
Fusion energy feels like one of the biggest clean-energy promises of the future, but most people never get to experience why it is so hard. The real control problem is hidden behind papers, lab machines, and technical plots.
I wanted FusionPilot to make that problem feel immediate: can you stabilize the fourth state of matter with two controls while the plasma keeps fighting back? And then, can an AI do it better?
The project was inspired by reinforcement-learning work for fusion control, especially the idea that AI can help manage fast, unstable physical systems that are difficult for humans to tune by hand.
What it does
FusionPilot is a browser-playable fusion plasma control simulator.
You can learn how heating and fueling affect a simplified plasma, try to survive random disturbances in Operator Challenge, and race against different AI policies in AI vs You mode. The human and AI receive mirrored disturbances and actuator bumps, so the comparison is fair.
The current prototype includes:
- A 0D plasma simulator with temperature, density, fusion power, confinement, and disruption logic.
- A clean Three.js particle torus visual for the reactor core.
- Operator Challenge with difficulty settings.
- Reactor scenarios: Standard, Compact, Heavy, Storm, and Precision.
- AI policies: random, constant, rule-based, and trained SAC.
- A trained Stable-Baselines3 SAC actor exported into browser-readable JSON.
- Post-failure theory explaining why the plasma collapsed.
It is not a real tokamak controller. It is an educational prototype designed to make plasma control and AI-for-science understandable in a few minutes.
How we built it
The simulator core is written in Python with NumPy. I built a simplified 0D plasma model, then added disturbance scheduling for ELM-like heat losses, density pumpouts, and heating noise.
On top of that, I added a Gymnasium environment and trained a SAC reinforcement-learning agent using Stable-Baselines3. The trained actor was exported into JSON so it can run live in the browser race mode without needing a backend.
The frontend is built with vanilla JavaScript, HTML, CSS, and Three.js. The plasma visual is a particle-based torus with cyan, violet, magenta, and electric-blue energy. The UI is designed like a dark reactor console with learn, operator, and race modes.
I also added tests, npm demo commands, a README, a changelog, scenario presets, difficulty controls, and honest documentation around what is real, what is simplified, and what is still experimental.
Development tools included VS Code, OpenAI Codex, and Claude Code.
Challenges we ran into
The hardest part was making the prototype feel real without pretending it is real physics. Fusion plasma control is incredibly complex, so the model had to be simplified enough for a hackathon demo but still meaningful enough to show stability, disruption, and control tradeoffs.
Balancing the game was also tricky. At first the operator mode was too easy because the plasma could survive without touching anything. Then the random slider pressure became too hard. I tuned it so Easy, Normal, and Hard feel different without becoming unfair.
Another challenge was the AI story. The trained SAC agent now survives the standard benchmark, but the tuned hand-coded heuristic still slightly beats it on mean reward. I kept that honest in the README instead of overselling it.
The plasma visual also took iteration. The first version looked too cloudy and smoky, so I rebuilt it toward smaller, sharper, more visible particles with a cleaner reactor-ring feel.
Accomplishments that we're proud of
I am proud that FusionPilot is not just a static mockup. It is a working vertical slice:
- The simulator runs.
- The browser demo runs.
- The AI race runs live.
- The SAC actor is actually exported into the frontend.
- The human and AI get matched disturbances.
- The app explains failure after disruption.
- The README and changelog honestly document the scope and limitations.
- Tests pass, and the project can be run locally with simple commands.
The strongest part is the moment where a person tries to keep the plasma alive, feels how unstable it is, and then sees why AI-assisted control is interesting.
What we learned
I learned that the demo clarity matters as much as the model. A technically complex project only works for judges if the interaction makes the idea obvious fast.
I also learned how sensitive reinforcement learning is to reward shaping. Survival alone is not enough; the policy also needs to maintain useful plasma conditions without drifting toward unsafe limits.
On the frontend side, I learned that visual tuning changes the entire feel of a science demo. The plasma needed to look controlled, energetic, and readable, not like a blurry cloud.
Most importantly, I learned how to frame an AI-for-science prototype honestly: FusionPilot is not a real fusion controller, but it can help people understand why fusion control is hard and why AI might matter.
Submission requirements by ML Empowerment
Project Title
FusionPilot
Short Tagline
Can you keep a simulated fusion plasma alive longer than an AI?
Project Description
Problem Statement
Fusion energy could become one of the most important clean-energy technologies of the future, but the control problem is hard for most people to see, feel, or understand. Plasma stability, heating, fueling, disruptions, and AI control are usually hidden inside research papers, expensive machines, or highly technical simulations.
That creates a public understanding gap. Fusion is often described as "clean energy from the future," but people rarely get to experience why it is difficult or why intelligent control systems matter.
Solution Overview
FusionPilot turns the plasma-control problem into a playable browser prototype. The user adjusts heating and fueling to keep a simplified fusion plasma stable while disturbances push it toward disruption. Then they can race against an AI policy under the same conditions.
The project combines a small 0D plasma simulator, a reinforcement-learning SAC agent, scenario presets, difficulty settings, and a clean particle-based reactor visual. It is not claiming to control a real tokamak. It is an educational prototype that makes the core idea intuitive: fusion plasmas need constant balancing, and AI can help reason about fast unstable systems.
Key Features
- Learn Mode: experiment with heating and fueling sliders and immediately see how the plasma responds.
- Operator Challenge: survive random actuator drift, ELM-like heat-loss events, density pumpouts, and stability limits.
- AI vs You Race: human and AI receive mirrored disturbances and actuator bumps so the comparison feels fair and understandable.
- Trained SAC Agent: a real Stable-Baselines3 SAC policy was trained and exported into browser-readable JSON for live race mode.
- Policy Choices: compare trained SAC, rule-based, constant, and random policies.
- Difficulty Settings: Easy, Normal, and Hard tune the size and intensity of control disturbances.
- Reactor Scenarios: Standard, Compact, Heavy, Storm, and Precision change the reactor feel, stability margins, disturbance weather, and round pacing.
- Failure Theory: after a disruption, the app explains what likely failed using plasma pressure, temperature, density, and stability logic.
- Premium Plasma Visual: a clean Three.js particle torus with cyan, violet, magenta, and electric-blue particles.
- Hackathon-Friendly Demo Flow: three clear panels show learning, manual control, and AI-vs-human comparison without needing a backend server.
Technologies Used
- Python
- NumPy
- Gymnasium
- Stable-Baselines3 SAC
- Vanilla JavaScript
- Three.js
- GLSL-style particle shader material
- HTML / CSS
- JSON model and trajectory exports
- Node.js / npm scripts
- VS Code
- OpenAI Codex
- Claude Code
Target Users
- Students learning about fusion energy or AI control
- Educators and science communicators explaining why fusion is hard
- Hackathon judges evaluating practical AI-for-science prototypes
- Developers curious about reinforcement learning and simulation
- General users who want an interactive way to understand clean-energy research
Positive Social Impact
FusionPilot supports clean-energy education. It makes a complex scientific problem approachable, visual, and interactive instead of abstract. By helping non-experts understand plasma instability and AI-assisted control, it can increase curiosity around fusion energy, AI-for-science, and the engineering needed for future low-carbon power systems.
Project Link / Repository
Repository:
https://github.com/josemacontrerasp-arch/fusionpilot
Live demo:
No hosted deployment yet. The project runs locally from the repository.
Local demo command:
npm install
npm run dev
Then open:
http://localhost:5173/web/
Alternative static server:
python scripts/serve.py
Then open:
http://localhost:8000/web/
Team Details
Solo submission:
Jose Maria Contreras Prada - concept, simulation, frontend, reinforcement learning training, visual design, documentation, and demo preparation.
AI Usage
FusionPilot uses two kinds of AI:
- In the product: a SAC reinforcement-learning policy trained with Stable-Baselines3 to control heating and fueling in the toy plasma simulator.
- During development: OpenAI Codex and Claude Code supported coding, debugging, documentation, implementation planning, and design iteration. The project direction, testing choices, final scope, and hackathon decisions were made by the developer.
Honest Scope Notes For Judges
- FusionPilot is an educational 0D toy plasma simulator, not a real tokamak controller.
- The trained SAC agent survives the standard benchmark, but a tuned heuristic still slightly beats it on mean reward in the current evaluation.
- Scenario modes are built for demo clarity and intuition; they are not calibrated reactor designs.
- The current prototype is strongest as an interactive learning tool for AI-assisted scientific control.
Log in or sign up for Devpost to join the conversation.