Devlog 6 - Flight Comparison Dashboard!

Overview

In this cycle, I expanded FlightScope’s analysis capabilities with a new Flight Comparison Dashboard! Now, users can load in two flights at the same time, comparing trajectories and detected flight events side-by-side. These additions make it endlessly easier to analyze design changes, motor selections, and overall flight performance across multiple launches.

What’s New

• Added a dedicated Flight Comparison Dashboard.

• Implemented dual-flight visualization for altitude, velocity, and orientation telemetry.

• Added automatic launch detection and time normalization so flights can be compared from liftoff.

• Implemented automatic event detection for:

  • Motor burnout
  • Apogee
  • Parachute deployment
  • Landing

• Added event markers directly onto comparison graphs.

• Added a Comparison Summary table displaying key event timestamps for both flights side-by-side.

• Improved dashboard responsiveness by moving admin sidebar initialization outside of rendering bottlenecks.

• Updated docs and README! By the way, FlightScope is fully public on GitHub, go check it out :)

Challenges

The challenge this time around was making sure the flight comparison dashboard was actually useful, so I spent some time designing features such as time normalization and side-by-side data viewing to make it very clear to the user where flight differences were present.

Next Steps

• Improve flight render with trajectory path
• Expand visualization tools with synchronized playback and side-by-side flight rendering.

So much progress is being made on this funny little program, I’m so very pleased with how FlightScope is coming along! That’s all for now, folks. See you in #7!

Devlog 5 - Zenith, Azimuth, and Flight Rendering!

Overview

This development cycle focused on major new steps to improve the dashboard. The biggest addition was a complete 3D flight reconstruction pipeline capable of calculating rocket orientation from telemetry data and rendering the flight path frame-by-frame.

What’s New

• Implemented zenith and azimuth telemetry support to determine rocket orientation throughout flight.
• Added a 3D rendering engine capable of visualizing rocket orientation and position over time.
• Created frame-by-frame flight playback controls directly within the dashboard.
• Added automatic rendering of flight paths using telemetry stored in the FlightScope database.
• Combined flight frame renders into video playback, adding an additional layer of visualization to flight analysis.
• Optimized rendering performance through image caching and improved frame loading behavior.

Challenges

This chunk of progress was heavy on debugging.

The first challenge was reconstructing a realistic rocket orientation from flight data. Position alone wasn’t satisfying in replay, so I implemented zenith and azimuth calculations that adds rotational orientation to the flight replay

The biggest issue I had, however, was actually combining flight frames into a video and implementing it on the dashboard. Video formats didn’t treat me well, but I figured out the correct pipeline with lots of trial and error and checks of every step of the system.

Next Steps

• Continue improving rendering performance for larger flights.
• Expand the visualization system with additional flight annotations and overlays.
• Improve playback controls and timeline navigation.

FlightScope has evolved from plotting telemetry to actually visualizing the flight itself. Seeing a rocket fly through a reconstructed 3D trajectory using real telemetry data is a huge milestone for the project, and I’m excited to keep pushing the visualization tools further.

Devlog 4 - UI Overhaul, Resilient Data Importing, and OpenRocket Export Compatibility!

Overview

I’ve spent more time improving FlightScope’s usability and flexibility, focusing on a cleaner code structure, a more resilient data importing pipeline, and compatibility with OpenRocket simulation exports.

What’s New

• Refactored the backend by separating dashboard, database, and data importing logic into dedicated modules.
• Improved the CSV upload flow to handle more file formats and clean incoming telemetry automatically.
• Added compatibility with OpenRocket CSV exports, including automatic unit detection and conversion for feet, meters, and Gs.
• Added safeguards to flight event detection to make analysis more reliable.
• Created a GitHub README! Go check it out, it’s linked at the bottom of the devlog :)

Challenges

Getting OpenRocket compatibility working was more difficult than expected due to differences in column names, units, and CSV formatting. I redesigned the import pipeline to standardize telemetry data before it reaches the database, making FlightScope much more flexible.

Next Steps

• Continue refining the FlightScope UI and overall user experience.
• Add support for more telemetry formats.
• Expand flight analysis and visualization tools.
• Make an online demo for you all to try out! (I could have written another 3 devlogs just about my challenges with this… we will save it for next time.)

FlightScope is now fully documented on GitHub:
https://github.com/zombieking1555/FlightScope

devlog 4 in the bag, now that’s some type stuff. And check this demo:

Devlog 3 - Flight Simulation Overhaul, Data Trimming, and Flight Event Detection!

Overview

Spent more time improving FlightScope’s flight data pipeline, with a focus on making the test flights more realistic, trimming extra idle data, and detecting key flight events more reliably.

What’s New

• Reworked the flight simulator to generate more realistic telemetry, including pre-launch idle, boost, coast, parachute descent, and post-landing idle.
• Added acceleration support throughout the database and telemetry pipeline.
• Implemented automatic detection and annotation for launch, burnout, apogee, parachute deployment, and landing.
• Trimmed pre-launch and post-landing idle data so plots focus on the active flight window.
• Regenerated test flights with updated simulation parameters.

Challenges

Getting event detection to work reliably took some tuning, especially with noisy acceleration data. Landing detection also needed a little extra care so the plots would stop cleanly at touchdown instead of including a lot of extra idle data.

Next Steps

• Tune detection thresholds more easily from the UI.
• Add tests for the event detection logic.
• Continue improving the database and telemetry handling.

FlightScope is really coming along! I’m excited to see where this project takes me until the next devlog.

Devlog 2 - Database Initialization, Dashboard Pages, and More!

Overview

Spent more time developing FlightScope, focusing on improving the local flight database structure and making smaller quality-of-life changes to keep the app scalable and easier to maintain.

What’s New

• Added automatic database initialization so flights.db is created locally instead of being stored in GitHub.
• Added a Database Manager page to view, manage, and delete individual flight records after upload.
• Refactored several backend functions to improve consistency and prepare the app for future features.

Challenges

Removing flights.db from GitHub was more challenging than expected (thanks, .gitignore). This led to the creation of create_db.py, which removes the dependency on a tracked database file and allows FlightScope to generate a local database automatically on startup.

Next Steps

• Expand the FlightScope dashboard with richer flight analysis and visualization tools.
• Support additional CSV data fields for more detailed and comprehensive flight reviews.

It’s been real, see you next devlog.

Devlog 1 - Streamlit uploader + SQLite storage + basic flight plotting

Overview

Added a Streamlit app that lets me upload flight CSVs, stores telemetry in a local SQLite database, and plots Altitude vs Time. I also added a small test data script that generates synthetic 200 Hz flight logs so I can quickly test the interface without real rocket data.

What’s new

• Streamlit CSV uploader for flight data
• SQLite database for storing flight metadata and telemetry
• Altitude vs Time interactive plot using Plotly
• Synthetic flight generator (test_data_writer) producing 200 Hz test flights

Data pipeline

• Upload CSV → validate → parse numeric values
• Store flight metadata in flights table
• Store time-series data in telemetry table
• Query SQLite → render plots in Streamlit

Challenges / friction

• CSV validation required enforcing numeric types for altitude and velocity
• Handled missing or invalid data during import
• Added duplicate filename detection to prevent overwriting flights
• Admin “Clear Database” flow required Streamlit session_state + rerun handling due to UI reset behavior

Design decisions

• Chose SQLite + pandas for simplicity and local-only operation
• Avoided external database dependencies to keep setup lightweight
• Kept CSV import as the ingestion layer for flexibility
• Added synthetic test data generator to speed up UI development and debugging

Next Steps

• Improve the upload UX (showing row counts and import status)
• Add per-flight summary stats
• Allowing CSV export from the database.

Having a lot of fun with this project, see you in the next devlog!