Cal STAR
Space Technologies and Rocketry is UC Berkeley's high-power rocketry team: eighteen complete vehicles, three liquid engines, and a 27,326 ft apogee record over ten years of launches. I'm on the avionics subteam. This page is the club, the software monorepo we build it on, and what I do inside it.
- Repo
- github.com/calstar/STAR — public, docs at calstar.github.io/STAR
- Club
- stars.berkeley.edu · public wiki
| Complete vehicles | 18 |
|---|---|
| Liquid engines | 3 (LE4 in design) |
| Apogee record | 27,326 ft — Caldera, IREC 2024 |
| Launch history | 10+ years, since URSA Minor (Dec 2016) |
Subteams
| Team | Owns |
|---|---|
| Aerostructures | airframe, fins, recovery — everything that holds the rocket together and brings it home |
| Propulsion | the liquid engines, from the injector out: LE1 ELLIE, LE2 ALULA, LE3 Diablo, LE4 |
| Avionics | the boards, firmware, and ground software that sense, control, and record a flight or a hotfire |
| Payload | the science that rides along — muon detectors, fuel cells, target-detection |
| Operations | launches and hotfires: logistics, safety, procedures |
| Outreach | schools, workshops, demos |
| Media | photo, video, socials, the public website |
Sponsors include Boeing, Blue Origin, GM, Dassault Systèmes, Onshape, Ansys, JLCPCB, and the Space Sciences Laboratory. Applications open each fall at apply.starberkeley.org.
| Era | Name | Kind | What | Headline |
|---|---|---|---|---|
| 2026– | LE4 | engine | 4th liquid engine — engine, feed system, tanks, and airframe in-house | in design |
| May 2026 | Gojira | vehicle | high-performance solid; first reusable aluminum high-altitude BP recovery charges | 20,000 ft · ~Mach 1.6 |
| 2024–2026 | LE3 “Diablo” | engine | 3rd liquid engine; the custom DAQ that monitors and commands every hotfire | custom DAQ |
| IREC 2025 | Excalibur | vehicle | competition solid | 10,000 ft target |
| 2025 | Glamourous Glennis | demonstrator | LE3 solid demonstrator for a new parachute deployment system | Mach 1 |
| IREC 2024 | Caldera | vehicle | two-stage vehicle | 27,326 ft — UC Berkeley record |
| 2021–2024 | Flight Computer | avionics | in-house flight computer: 13 sensors, sensor fusion, extended Kalman filter | 13 sensors |
| IREC 2023 | Calvisitor | vehicle | air brakes + dual payload | 10,023 ft · 4th overall |
| 2023 | ALULA (LE2) | vehicle | first liquid vehicle | 6,126 ft — first recovered liquid |
| 2022 | Pinkbeary | vehicle | first two-stage vehicle | 2,377 ft · stage separation |
| 2021–2022 | ELLIE (LE1) | engine | first liquid engine | 6 s test fire |
| IREC 2021 | BearForce 1 | vehicle | largest rocket to date, Mojave Desert | 10,000+ ft |
| 2021 | MINDI | vehicle | 2-inch minimum-diameter rocket | 14,000 ft projected |
| Nov 2019 | AirBears | vehicle | dual-deploy recovery | 4,509 ft · within 1 ft of prediction |
| 2018 | Arktos | vehicle | NASA Student Launch | 5,323 ft |
| 2016–2017 | URSA Major / Minor | vehicle | NASA SL competition vehicle; first high-powered rocket | Huntsville, AL |
Everything from the firmware on a sensor board, to the ground station that records a hotfire, to the optimizer that designed the engine lives in one repository. It is a collection of mostly-independent subprojects, each with its own README, setup script, and ./dev.sh; a top-level setup.sh dispatches so editing the P&ID never forces you to build Rust and elodin-db. CI runs per-directory: the C++ DAQ integration test, PlatformIO firmware builds plus host unit tests, pytest gates and frontend builds for each design tool, a 5 MB large-file guard, and Doxygen to GitHub Pages on every push to main.
| Directory | What it is | Stack |
|---|---|---|
daq-server/ | Ground DAQ server / flight software. Receives sensor data over the network, logs it, drives the state machine and actuators, serves the live web GUI used during hotfires. | C++ · TypeScript/Node · Next.js · Elodin DB |
firmware/ | Board firmware for every avionics board (PT, TC, RTD, LC, Encoder, Actuator). Reads sensors, talks to the DAQ server over Ethernet, runs on-board abort logic. Subtree of calstar/DiabloAvionics. | PlatformIO · ESP32-S3 · C++ |
lib/DAQv2-Comms/ | The wire protocol shared by firmware and DAQ server — packet definitions, enums, (de)serialization. Single source of truth for what goes over the wire. | C++ (Arduino library) |
lib/stardesign/ | Design core shared by the design tools: per-user storage, cross-user sharing, version history (microversions + immutable releases, local volume or versioned S3). | Python |
lib/stardesign-ui/ | Client half of the same — Change dialog, checkout chip, read-only context, design API client. | TypeScript · React |
lib/feedtwin/ | Feed-system physics core: real-gas properties, component library, steady network solver, transient response from COPV to injector face. A library, not a service (ADR-0001). | Python · CoolProp · fluids |
EngineDesign/ | Engine design and optimization pipeline for liquid bipropellant engines. Chamber pressure is never an input — it is solved from tank pressures. Multi-layer optimizer, Numba-compiled physics kernel (~120× per candidate), stability analysis, RocketPy validation. | Python · FastAPI · React |
pid-designer/ | Interactive P&ID editor for the propulsion feed system. React Flow canvas, git-style versioning, every parameter stored as {value, unit, source, reference} so a run report can say which inputs were measured and which were guessed. | FastAPI · React + React Flow |
feed-twin/ | Feed-system simulator — COPV through regulator, tanks, lines, valves to the injector. Built on lib/feedtwin; the same schematic will show simulated physics, replayed test data, or a live DAQ stream. | Python · FastAPI · React |
star-openrocket/ | Onshape assembly viewer + centre-of-mass, stability, ascent dynamics, and recovery calculator. Loads from a build cache so the viewer costs zero Onshape API calls. | FastAPI · React + three.js |
starproject/ | Internal task tracker replacing OpenProject. Served at project.starberkeley.org. | Next.js · PostgreSQL · Prisma |
landing/ · auth/ · deploy/ | Gated internal-tools portal, the Google-login auth service, and the Caddy + docker compose stack that serves everything at *.starberkeley.org behind one @berkeley.edu login. | React · Python · Caddy · Docker |
website/ | The public site — Home, launch-history timeline, Leads, Sponsors, Join. Deployed to OCF. | React 19 · Vite · Tailwind |
How they fit together
design tools test / flight pipeline
+------------------------+ +------------------------------------------+
| EngineDesign/ | | firmware/ (ESP32 boards: PT/TC/RTD/...) |
| optimizes geometry | | | sensor data / heartbeat |
| & pressure curves | | v (lib/DAQv2-Comms wire protocol) |
| | | daq-server/ |
| pid-designer/ | | DAQ bridge -> Elodin DB -> backend |
| lays out the P&ID | | -> web GUI + state machine + control |
| feed-twin/ | | |
| star-openrocket/ | | |
+------------------------+ +------------------------------------------+
all four build on lib/stardesign (server) + lib/stardesign-ui (client)
and mount one shared userdata volume: browse a teammate's design,
take a copy, or share one and edit it together.The design tools deploy together at *.starberkeley.org behind a single Google login restricted to @berkeley.edu. Caddy asks the auth service about every request before forwarding it, so the apps carry no auth code of their own, and local development, which never runs Caddy, never sees a login screen. The DAQ server is the deliberate exception: it runs natively under systemd on the test stand, because the C++ bridge, elodin-db, and the board links need the hardware.
Each avionics board is an ESP32-S3 running a small state machine: boot, self-test the ADC and sensors, wait for the server to send its configuration, then stream sensor data and exchange heartbeats. If it loses the server's heartbeat it aborts on its own. Packets are packed binary over UDP, defined once in lib/DAQv2-Comms, so firmware and server can never disagree about the wire format. On the ground the DAQ server is eleven coordinated processes:
| Service | Does |
|---|---|
daq_bridge | C++ UDP receiver → Elodin time-series DB publisher |
sequencer | hotfire state machine + actuator commands over UDP |
calibration | raw sensor → calibrated sensor, Elodin → Elodin |
controller | RobustDDP controller, Elodin → PWM over UDP |
heartbeat | SERVER_HEARTBEAT to every board; lose it and the board aborts on its own |
config_broadcast | SENSOR_CONFIG / ACTUATOR_CONFIG pushed to boards at startup |
data_logger | CSV logger from Elodin |
ota | Ethernet over-the-air firmware flash |
backend + frontend | Node/TypeScript WS+HTTP backend, React/Vite GUI on :3000 |
./dev.sh --sim runs the whole pipeline against simulated boards, so the full-stack integration test needs no test stand. The predecessor of this stack, the Diablo static-fire ground control firmware, is still public at calstar/Diablo-FSW and calstar/DiabloAvionics.
- Avionics for high-power rockets (~30,000 ft apogee): custom PCBs in Altium Designer, soldered and tested under strict mass and volume limits.
- ESP32-S3 board firmware for the PT, TC, RTD, LC, and ATCOMM boards.
- The packed-binary UDP wire protocol (lib/DAQv2-Comms) both ends of the pipeline speak.
- The C++/TypeScript ground DAQ pipeline that runs liquid-engine hotfires across 13 networked boards.
- Tuned the actuator/valve board’s hotfire state machine: heartbeat timeout, abort, and connection-loss transitions.
- The mobile experience for STARProject, the team’s internal task tracker.
Board-level design credit is shared across the avionics leads; PCB sources live in the club's Altium 365 workspace rather than the public repo. My software contributions are in calstar/STAR. Tools I actually use: Altium Designer · KiCad 8 · Fusion 360 · ESP-IDF · PlatformIO · Saleae Logic 2. The rest of what I build is at /projects.