@prajithvishnur

Added a couple of late-minute changes to make it work better overall. Might add a backup api key later. Shipping for now!

Got a lot of scenarios for the game built. It’s going pretty well, also hosting it on git.

A few last-minute design tweaks. Ready to ship!

Made final tweaks. The app looks kinda awesome. Only downside is that it has Gemini free api limits…. but I think it’s almost ready to ship!

created a start screen that i think looks rlly cool. hope to turn this into an awesome space game.

Finally got it published on a website. Looking good. Worked on improving the ui. I think it’s going pretty well.

Working on getting the project put on a website. Everything seems to be going well so far. i worked on trying to make everything look cool and professional. I hope this goes well!

For the second major phase of my Stardance project, I transformed my local python program from a basic command-line interface into an immersive NASA Mission Control simulator. I learned a lot about python and API keys. I overhauled the user experience by building a retro-futuristic ASCII art boot banner, integrating ANSI color matrices for a custom green and cyan HUD terminal, and restructuring the system prompt to promote the operator to “Flight Director.” Technically, I expanded the architecture to dual-query multiple NASA assets simultaneously, including live orbital asteroid defense feeds and deep-space candidate star monitoring, while maintaining a persistent chat state pipeline so the assistant retains context across multiple telemetry commands. I hope to improve this so much and turn it into a website. Right now its talking using my mac.

For my first devlog, I successfully built and launched the initial prototype of my JARVIS AI assistant using Python on macOS. By integrating NASA’s open APIs with the Google-GenAI SDK running a gemini-2.5-flash model, I created a continuous terminal chat loop that behaves exactly like Tony Stark’s sophisticated assistant. Despite hitting a package namespace conflict and a temporary 503 server capacity spike, the script’s exception handling kept the program alive, ultimately delivering a live, in-character briefing on NASA’s current Mars and Artemis missions.

attempted to make changes but resulted in errors. went back to orignal code.

Fixed minor bugs and reshipped!

The Compliance Patch & UI Optimization
After submitting the initial build, I ran into a quick compliance hurdle regarding explicit AI disclosures on the actual platform interface. I jumped straight back into the codebase to make the entire workspace 100% airtight and transparent. I embedded a formal AI Attribution and Usage Declaration directly into the live user interface, placing a clean summary anchor inside the sidebar control console and a comprehensive engineering footer at the very bottom of the main dashboard viewport.
While I was under the hood, I also took the opportunity to optimize the front end and clear out some native terminal warnings. I refactored the data logging layout, swapping out the deprecated use_container_width parameters for the updated width=“stretch” property to ensure full compatibility with the latest Streamlit engine standards. After wrestling with a quick remote branch sync in the terminal, the compliance patch was successfully merged and pushed live to GitHub. The digital twin is now fully transparent, warning-free, and officially certified for the final judging review!

For this final sprint, I focused entirely on turning this from a basic simulation script into a production-grade web application. I spent a lot of time stripping out the default Streamlit styling and injecting custom CSS overrides to build a bespoke, dark-mode HUD dashboard. Now, the platform features glowing cyan metric highlights and a translucent visualization canvas that gives it an elite, aerospace-grade engineering look.

On the physics side, I ran rigorous baseline stress tests to validate the calculation pathways against real-world microplastic data. Under steady-state parameters, the simulation successfully managed an intake flux stream of 48.8 liters per minute and a filtrate discharge of 21.9 liters per minute, locking in a perfect 100% deflection purity index with zero boundary leaks.

I also fully deployed a persistent data logging system using pandas, meaning every single time you tweak a slider for the raker geometry or debris load, the engine instantly tracks those telemetry changes inside a local session state. With the final documentation complete and the repository looking insanely clean, the digital twin is fully public, responsive, and ready to ship.

The interactive demo is officially live, and we have finally crossed the finish line. What started out as a quiet local Python script running in a terminal has been completely transformed, polished, and deployed into a public, dark-themed Streamlit web application. This final release brings together all the heavy engineering frameworks, integrating full hydrodynamic continuity tracking to maintain perfect mass balance across the filtration channel alongside a high-frequency Storm Surge Mode designed to stress-test the bio-inspired manta ray gill raker geometry against chaotic fluid vectors in real time.
The entire codebase is public, fully synchronized with its environment handlers, and streaming live right now for the world to see. You can jump straight into the live web workspace at https://manta-ray-filtration-system.streamlit.app to test the parameters yourself or explore the open-source repository at https://github.com/prajith-vishnu/manta-ray-filtration-system to dive into the mathematical physics documentation and see how the final build came together.

For this next leg of the build, the simulation officially made the massive leap from a quiet backend script running in the terminal into a full-blown, interactive engineering dashboard. I wanted to turn this into a live, playable workspace where anyone could mess with the variables on the fly, so I integrated real-time sliders for flow velocity and raker height alongside a dynamic polymer selector console. Now, instead of hardcoding numbers and re-running the script, you can instantly tweak the setup and watch how different plastics react to the changing fluid currents right in front of you.
The absolute highlight of this session was shipping what I am calling “Storm Surge Mode.” This is basically a brutal stress-test toggle that injects chaotic vertical acceleration forces and fluid velocity eddies straight into the simulation. It completely disrupts the clean current to mimic critical, real-world storm conditions, letting me see if the bio-inspired raker geometry can actually hold its own when things get rough out in the open ocean.
To back all of this up visually, I also had to do a major physics rewrite under the hood. Previously, there were some annoying visual path-clipping bugs where the particle trails would look jagged or cut off near the boundaries. By moving the coordinate logging logic directly inside the nested sub-stepping loop, I finally cleared out those tracking glitches. The engine now delivers pixel-perfect precision right around the edges of the rakers, making the visual simulation look incredibly sharp and professional.

Once the basic single-particle loop was stable, it was time to scale up the complexity to see how the system handled a more realistic, crowded environment. I upgraded the core engine to process a chaotic intake cloud of 50 distinct microplastic particles, all spawning at completely randomized vertical entry points to simulate a true messy current. Throwing that many objects at a high flow velocity of 250 millimeters per second immediately triggered a classic simulation glitch called tunneling, where particles move so fast between frames that they literally skip straight through solid walls without registering a collision.

To fix this boundary breakdown, I implemented a sub-stepping physics processor that cracks open each standard time frame and divides it into 10 microscopic intervals, dropping the delta time down to a razor-sharp one-thousandth of a second. Alongside the processing fix, I overhauled the raker profiles from flat shapes into true downstream-slanted fins using a two-slope geometric matrix that features a gentle leading edge paired with a steep trailing edge. This combination of tighter time tracking and accurate geometry paid off completely, with the high-fidelity engine locking in a mathematically verified 100% filtration efficiency yield and proving that the bio-inspired boundary layer forces can successfully override downward suction to execute clean ricochet separation.

Honestly, working through these complex physics anomalies and structuring the data loops has made things click in a way they never had before, and I am really starting to feel like I’m getting the hang of programming now. My confidence with Python is hitting a whole new level, especially because I have been leveraging AI as an interactive coding partner throughout this entire sprint. Instead of just staring at errors or trying to guess why a boundary layer isn’t registering, I use the AI to brainstorm script architectures, debug tricky syntax bottlenecks, and deeply understand how to properly execute those micro-stepping intervals. It honestly feels like having a senior developer sitting right next to me, helping me bridge the gap between the fluid dynamics math in my head and the actual code, which has completely accelerated how fast I can learn and ship clean software.

This project actually started because of a problem I ran into during a previous experiment. I had recently built a working microplastic filter using a homemade castor oil-based ferrofluid, and while it actually worked, it bothered me how much material was wasted in the process. I knew there had to be a cleaner, more sustainable way to separate these particles without constantly burning through physical resources, which is what led me deep into the research of marine biology. That is when I discovered how manta rays use vortical separation inside their gill rakers to filter food out of the ocean without ever clogging. My ultimate goal is to take this digital research and use it to manufacture a real, physical filter one day, but the first step was proving the math could work in a digital environment.
To kick off development, I officially built and launched the core simulation engine inside a script called flow_model.py. The primary challenge here was establishing proper physical scaling, taking a real-world oceanic flow velocity of 31.3 kilometers per hour and accurately converting it down into localized millimeter-per-second computational forces inside the channel. I integrated a sine-wave mathematical function to simulate the unique, bio-inspired vortical fluid behavior that happens when water hits the geometry of the ray’s rakers. The initial tracking code is running incredibly well, calculating smooth coordinate paths for the particles and resolving a full 100mm transit loop in just 0.40 seconds.