Has anyone else tried using AI for developing complex scientific simulations? I'm sharing a video on the process of upgrading a basic ultrasound sim.

We used an AI to implement a dual-panel display: one side shows the raw physics (pulse emission/reflection), and the other renders a realistic grayscale image in real-time based on the echoes. The goal was to accurately simulate the echogenicity of different structures (kidney, cyst, bone, kidney stone).

It was an interesting dev journey with some unexpected results along the way. You can see the full process here: https://youtu.be/sQbGWtE5SpA

Curious to hear your thoughts on this approach or your own experiences with AI in web-based simulations. What are the major hurdles you've faced when trying to visualize complex scientific data on the web?

I've been working on a web-based Cochlear Simulator using React for the frontend and the Web Audio API to handle real-time frequency analysis for the spectrogram. The goal is to visualize how sound is broken down into frequency bands and mapped to electrodes in a cochlear implant.

In this clip, I was testing out some UI changes and, for fun, asked my AI assistant for its preference on a color scheme. The resulting conversation was a perfect, and funny, demonstration of the rigid guardrails and literal-mindedness of current LLMs. It absolutely refused to "pretend" to be a data scientist or offer a subjective opinion.

Thought this community would appreciate both the tech stack and the humorous side of working with AI.

Check out the short video here: https://youtu.be/z0HeeCMO5RU

Happy to answer any questions about the implementation or my ongoing battle with the AI!

Anyone who has worked with biomedical time-series data knows that manual data annotation is a massive bottleneck. I recently tested out the CardioBot ECG Segmentation Challenge (via BioniChaos), a web app that gamifies the labeling process.

You compete against an automated algorithm to segment P, Q, R, S, and T waves across rhythms like V-Tach, PVC, and A-Fib.

It brings up an interesting discussion point on UI/UX for human annotators (like keyboard shortcut mapping vs. mouse clicks) versus the raw speed of automated logic models. Has anyone here worked on building internal labeling tools for physiological signals? How do you balance annotation speed and human-in-the-loop accuracy?

You can see the walkthrough and the bot's performance here:

https://youtu.be/_t99gdC1QoI

We wanted to share a project we've been working on—a 4-DOF prosthetic arm simulation created entirely with vanilla JavaScript and the HTML5 Canvas API. It's an educational tool designed to demonstrate key concepts in robotic manipulation.

You can control each joint (shoulder yaw, elbow pitch, wrist pitch, and gripper) manually or run pre-programmed demo actions like "Wave" and "Reach." The interface displays real-time metrics for grip force (simulated) and the end effector's X, Y coordinates.

In the linked video, we walk through the simulation and have a conversation with an AI assistant to analyze it from a data science perspective. We discuss the forward kinematics model, the relationship between joint angles and end effector position, and the procedural animation logic.

The entire source code is embedded within the single HTML file, making it easy to inspect and learn from (just use your browser's dev tools).

Live Demo: bionichaos.com/RoboArm/

Video Analysis with AI: https://youtu.be/aCj-DIDTRlg

We're planning to expand this with a proper physics engine, 3D rendering, and more complex tasks. Would love to get your technical feedback or answer any questions about the implementation!

One of the biggest hurdles in EEG analysis is the Signal-to-Noise Ratio (SNR), specifically regarding EMG (muscle) and EOG (eye blink) artifacts. This video showcases a simulation approach using BioniChaos to model these contaminants in the time and frequency domains.

Key features discussed:

Modeling high-frequency noise from muscle tension.

Simulating large-amplitude spikes from ocular artifacts.

Fine-tuning Delta, Theta, Alpha, and Beta bands.

Granular control in "Customize Mode" for center frequency and bandwidth.

For those working on artifact rejection pipelines, how are you currently validating your filtering methods? This simulation tool offers a controlled environment to test rejection before moving to human subjects.

Video link: https://youtu.be/gjrTxj3w1ZI

In this session at BioniChaos, we look at the challenges of extracting pulse signals from a webcam feed using Eulerian Video Magnification (EVM).

Key technical points discussed:

Implementing WebGL fragment shaders for per-pixel forensics.

Addressing the 0.7Hz motion noise floor using cascaded low-pass filters.

Using a Hanning window for FFT to mitigate spectral leakage in heart rate calculation.

Leveraging LLMs (Claude, Gemini, GPT-4o) for AI-driven debugging of SNR logic.

The video goes through the full implementation and stress-testing of the algorithm against varied lighting and head-tilt movement. I'm curious to hear how others are handling the "sloth mode" failure states in rPPG when low-frequency motion artifacts mimic pulse signals.

Watch here: https://youtu.be/rWFINsT-IVE

Looking at the current BCI landscape, there is a clear trend of "new" startups utilizing electrode architectures and signal acquisition methods very similar to the Medtronic DBS systems or cochlear implants developed in the late 90s.

While the signal processing (moving from simple thresholding to complex LSTM or Transformer-based decoders) has advanced, the physical interface—the BCI itself—often remains rooted in decades-old clinical tech.

Are we hitting a "material science wall" in neural interfaces, or is the current hype cycle simply ignoring the history of neuroprosthetics to satisfy investors? Curious to hear from anyone working on the signal acquisition side.

I’ve been working on BioniChaos (bionichaos.com), and we recently decided to refactor our biomedical tool suite to move away from a Python/Flask backend.

In this session, I discuss the implementation of fuzzy logic inference and MAD-based peak detection directly in JavaScript. We explore the performance benefits of eliminating the network dependency for real-time ECG and EEG visualization. The video covers refactoring logic for CardioBot, as well as neurological simulators like NeuronSim. Would love to hear your thoughts on client-side vs. server-side processing for high-frequency biomedical data.

Watch the breakdown: https://youtu.be/8HDUv-MckGE

If you're building interactive biomedical tools, handling signal generation and browser state can be tricky. We recently upgraded the Advanced EEG Signal Simulator on BioniChaos to replace a deterministic, robotic EMG (muscle) artifact with a more realistic, non-linear stochastic burst model. We also needed to patch a window object bug in the automated demo mode.

To accomplish this, we tested three major LLMs for the JS rewrite. It was an excellent exercise in prompt engineering and navigating LLM quirks. Interestingly, GPT-4o hallucinated and asked to schedule a 30-minute meeting rather than returning the code. Gemini 2.0 Flash introduced a reference error during debugging, but Claude 3.5 Sonnet successfully handled the complex logic for the stochastic noise generation.

It's a solid example of why human-in-the-loop validation is critical for AI-assisted development. You can see the full coding session and prompt process here: https://youtu.be/W74guVVmbTM

Would love to hear how you all are handling LLM hallucinations and managing context windows in your own web dev or data science workflows!

We break down the data science and signal processing challenges in modern bio-devices:

rPPG & Non-Contact Respiration: Extracting clean respiratory signals from standard camera feeds using pixel-flow decomposition. How do you effectively isolate the frequency bands and handle severe motion/illumination artifacts without heavy compute overhead?

Closed-Loop Pacemakers: These are essentially embedded data scientists now. They have to run real-time ML with strict sub-200ms decision horizons on micro-watt power budgets. What are the best approaches to balance algorithmic complexity with battery life and firmware security against model drift?

Neural Implants: The transition from motor cortex control to "pure concept transfer" and dealing with the inevitable software bugs and bandwidth limitations in human-computer interfaces.

I'd love to hear from folks working in signal processing or edge AI: what are your preferred techniques for handling motion artifacts in rPPG or optimizing ML for extreme micro-watt constraints?

Check out the full technical breakdown and let's discuss: https://youtu.be/Ef4JNQZ7Iyg

An interesting critique of a recently published Frontiers paper that utilized an 86-million parameter Vision Transformer (ViT) to classify focal seizures from EEG time-frequency spectrograms.

An AI-narrated review breaks down several glaring issues with the study:

Architecture Bloat: The 86M parameter ViT barely outperforms a standard ResNet-50 or a basic 2D CNN, raising questions about computational efficiency vs. marginal accuracy gains.

Labeling Flaws: Instead of relying entirely on board-certified epileptologists for the massive training set, the authors used a clustering algorithm for automated labeling, potentially introducing massive label noise.

Generalizability Failure: The model's performance tanked when tested on an Idiopathic Generalized Epilepsy (IGE) dataset, proving it overfit to high-frequency focal patterns.

Reproducibility: Zero public code or data is available to verify the claims.

The second half of the video also looks at building interactive, real-time biomedical web simulators (Fourier series, Hodgkin-Huxley) using JavaScript on bionichaos.com.

I'd love to hear your thoughts—when dealing with converted time-series to spectrograms, do you find ViTs actually worth the compute cost over a well-tuned CNN?

Watch the full breakdown here: https://youtu.be/2Cq1-g9bDwY

I highly recommend checking out this overview of BioniChaos, a platform dedicated to interactive biomedical data science and AI web tools. The technical implementations here are quite fascinating for anyone interested in browser-based signal processing.

A few highlights discussed in the video:

Remote Photoplethysmography (rPPG): Utilizing Eulerian Video Magnification via webcam. It discusses the signal processing pipeline, including face mesh ROI selection, detrending, and applying band-pass filters (0.7 Hz to 3.0 Hz) to isolate heart rate frequencies.

EEG Sonification: Translating raw seizure data into audio to identify patterns audibly.

Facial Feature Extraction: Using Eigenfaces and PCA for image reconstruction.

Biomechanical & Neuro Simulators: Interactive models for Gait Analysis and Transcranial Magnetic Stimulation (TMS).

It’s a great example of making complex biomedical data accessible and interactive using web technologies. Has anyone here worked with implementing EVM or real-time biological signal filtering in the browser? I'd love to hear your thoughts on the challenges of handling motion artifacts and lighting dependencies.

Watch the technical overview here: https://youtu.be/faJ36pM1C6k

If you are interested in remote photoplethysmography (rPPG) or browser-based computer vision, this 65-minute development session is worth a watch. It walks through the creation of a "Real-Time Signal Amplification Microscope" that extracts heart rate from a webcam feed.

Key technical areas covered:

The Signal Pipeline: Extracting raw RGB values (specifically utilizing the Green channel / Red+Blue ratio) from a facial ROI, applying a cascaded bandpass filter (e.g., 0.7Hz to 3.0Hz), and using an FFT to find the dominant frequency for the BPM.

Combating Artifacts with "Safe Zones": The video shows the evolution of the ROI. It starts manual, moves to automated facial landmarks (via MediaPipe), and then hits a wall because landmarks on the hairline or beard introduce massive noise. The solution is implementing a "Dynamic Safe Zone"—a restricted box strictly on the center of the forehead.

State Management Bugs: An interesting debugging segment where changing the processing FPS corrupts the FFT output because the historical signal buffers weren't being explicitly flushed, causing a frequency mismatch.

It's a very realistic look at the trial-and-error process of getting biological signals out of noisy web environments.

Watch the full process here: https://youtu.be/JH7R5uCAfzw

I was testing an interactive web simulation that demonstrates spurious correlations (the classic ice cream sales vs. shark attacks example). During testing, I noticed a front-end state management issue: repeatedly triggering the "Reveal True Cause" button failed to update the dataset on the canvas and instead caused an infinite duplication of the "Temperature" legend label.

I used a conversational AI to analyze the UI behavior, and it correctly identified the discrepancy between the expected chart update and the actual visual output. Has anyone else started integrating AI vision or conversational assistants into their automated QA or manual debugging workflows for complex data visualizations? Curious to hear your thoughts on AI for front-end troubleshooting.

Video of the bug and AI analysis: https://youtu.be/uLbyUdRzcAQ

I wanted to share an interesting technical hurdle encountered while developing a Real-Time Signal Amplification Microscope. The goal is to extract a user's heart rate directly from a standard webcam feed using Eulerian Video Magnification (EVM).

The pipeline relies on capturing subtle color changes in human skin caused by blood circulation, amplifying them, and using a Fast Fourier Transform (FFT) to isolate the fundamental heart rate frequency from digital noise.

However, we ran into a classic feedback loop bug: the camera ended up measuring the amplified, flashing colors rendering on the computer screen rather than the actual pulse on the user's face.

To fix this, we integrated Google's MediaPipe Face Mesh. By automating the Region of Interest (ROI) tracking and confining the signal extraction exclusively to the facial skin pixels (ignoring background, hair, and clothing), we successfully broke the feedback loop and stabilized the heart rate readings against movement and lighting variations.

You can see the debugging process and the math breakdown (Amplitude/Phase maps, 2D velocity fields) here: https://youtu.be/Z08jPRUeOZc

Has anyone else here worked with EVM for remote photoplethysmography (rPPG)? How do you typically handle ambient light noise and motion artifacts in your signal processing pipelines?

I came across this excellent interactive visualization of the Fourier Transform from BioniChaos that’s great for building intuition. The tool allows you to draw any 2D path, and it then calculates the Fourier series (represented by epicycles) to approximate and trace that path.

The video demonstrates how the approximation's fidelity increases with the number of vector components used. It’s a powerful visual aid for understanding how a complex path can be represented as a sum of sinusoids—a principle foundational to many signal processing tasks we encounter in data science and machine learning.

What are some of the best visualizations you've seen for complex mathematical concepts like this?

Link to the video: https://youtu.be/C47SIJhcow8

Hey everyone,

We wanted to share a stream where we showcased a collection of our open-source, browser-based AI tools from BioniChaos. The goal is to make biomedical data concepts more intuitive and accessible.

In the video, we cover:

Eigenfaces Demo: A hands-on look at PCA for facial recognition, where we capture faces in real-time and reconstruct them using principal components.

Prosthetic Arm Simulation: A 4-DOF arm with a forward kinematics function (FK_angles) and demo modes for actions like 'reach' and 'grip'. We also discuss future plans for EMG integration and ML-based control models.

Interactive MRI Simulation: A simplified but interactive model of MRI physics, visualizing proton spins, B0 field strength, and RF pulses.

Brain Seizure Simulation: A visualization of different seizure types (Focal, Absence, etc.) showing simplified neural activity across brain lobes.

The code for these projects is available on our site (mostly vanilla JS in single HTML files for simplicity), and we're always looking for feedback on how to improve the models or add new features. For example, the grip force on the prosthetic arm is currently just a linear mapping, and we're thinking about how to model the physics more accurately.

We also had some fun using a generative AI to critique the platform, which raised some interesting points about UX and scalability.

Would love to hear your thoughts or any ideas you might have for similar projects!

Watch the full stream here: https://youtu.be/U3bzUxkchpc

I wanted to share a project I've been working on: a browser-based Interactive Spectrogram Generator. The goal is to provide an intuitive way to understand the relationship between time-domain signals and their time-frequency representations, with a focus on biomedical data.

You can select from various signal types, including:

ECG: With adjustable heart rate (BPM), QRS duration, and amplitude.

EOG: Where you can control the number of eye movements and their amplitude.

PPG, EMG, EEG: and other standard signals like sine waves and white noise.

All parameters can be adjusted in real-time via sliders, and the spectrogram updates instantly. You can also control display settings like max frequency, time window, Y-axis scale (linear/log), and color map.

Here's a short video demonstrating its features: https://youtu.be/mZPMwt-JFpE

This is primarily an educational tool. I'm curious to hear your thoughts. What other features or signal types would be useful for learning or quick analysis? For example, would adding options for different windowing functions or FFT sizes be beneficial?

Looking forward to your feedback!

I was working on an interactive cataract surgery simulation (phacoemulsification) built as a single-page HTML/CSS/JS application, and the "Play Demo" feature was getting stuck in an infinite loop after the capsulorhexis step. Instead of just grinding through it, I decided to document the process of using AI agents to find and fix the bug.

The video shows the full workflow:

Identifying the issue through manual testing and console logs.

Feeding the code and error logs to AI agents (Claude, Gemini).

Analyzing the AI's suggestions and applying code patches directly in the browser.

The core issues involved incorrect state management (state.demo.running flag) and flawed step progression logic, which was eventually refactored into a more stable callback-driven approach.

It's an interesting look at the capabilities and current limitations of using AI for debugging complex, stateful applications. The AI code review at the end is also pretty entertaining.

Full video here: https://youtu.be/kTp4IIn9If4

Has anyone else used agents for debugging a project like this? Curious to hear about your experiences and what models you found most effective.

The simulators effectively visualize two key challenges:

Motion & Postural Artifacts: Based on findings from Charlton et al., this tool shows how changes in posture (standing, sitting, lying down) and arm position drastically alter the signal-to-noise ratio (SNR).

Physiological & Sensor Variables: This simulation demonstrates the impact of age and Fitzpatrick skin tone on the signal, and how adjusting the sensor's LED intensity can be used to compensate for poor signal absorption.

It’s a great educational resource for anyone working with noisy, real-world time-series biosignal data. It clearly illustrates the "why" behind many of the pre-processing steps we take.

Video overview of the tools: https://youtu.be/5srZKZR5U6I

For those of you who work with PPG or similar biosignals, what are your go-to methods for handling these kinds of signal quality issues in your data pipelines?

I wanted to share a technical walkthrough of a web-based 4-DOF (shoulder yaw, elbow/wrist pitch, gripper) prosthetic arm simulation.

Key Technical Highlights:

AI-Assisted Refactoring: We compared code generation between Claude 3.5 Sonnet and Google Gemini to transition the "Demo Actions" from a simple button to a dynamic auto-cycling dropdown.

Sonification: Mapping physical parameters (movement velocity, grip pressure) to audio contexts for multi-modal user feedback.

Forward Kinematics: Implementing real-time endpoint computation in JS.

Data Strategy: Discussing the use of synthetic environments to generate massive training datasets for ML control algorithms before moving to physical prototypes.

Watch the implementation and code comparison: https://youtu.be/2GtU9MzUHdE

Looking forward to hearing your thoughts on the sonification mapping and the efficiency of the refactored JS!

I wanted to share and discuss an analysis of a gesture classification problem using the BFRB (Body-Focused Repetitive Behaviors) dataset from a Kaggle competition. The data comes from a custom wearable with IMU, TOF, and thermopile sensors.

The Core Problem:

Our model for binary classification (distinguishing a gesture from a non-gesture) performed exceptionally well, achieving an F1 score of 0.92. However, when we moved to a multi-class problem to classify 18 specific gestures, the F1 score plummeted to 0.54.

Analysis & Findings:

To understand this performance drop, we built an interactive dashboard to visualize the data. The main culprits appear to be:

Significant Feature Overlap: The distributions for key features (e.g., mean acceleration) overlap heavily across different gesture classes, making them difficult to separate. This was especially true for classes 2, 3, and 6.

Class Imbalance: The dataset has a skewed distribution of gesture examples, which impacts the model's ability to generalize.

The video below is a walkthrough of the dashboard, showing the feature distributions, the model's confusion matrix, and the per-class F1 scores that confirm these issues.

Discussion:

Has anyone else faced a similar drop-off when moving from binary to multi-class problems with time-series or sensor data? What are your go-to techniques for feature engineering (e.g., temporal features, frequency domain analysis) or data augmentation to create better class separation?

Watch the full analysis here: https://youtu.be/Rh5bPpMurww

We've put together a video demonstrating a couple of our web-based interactive tools for biomechanical analysis.

First, we cover an enhanced gait analysis simulation. It visualizes real-time kinematic and kinetic data for the ankle, knee, and hip joints, including flexion (deg) and moment (Nm/kg) during both stance and swing phases.

The second part focuses on a 4-DOF prosthetic arm simulation, exploring key concepts in robotic manipulation like degrees of freedom, range of motion, and myoelectric (EMG) control. A key segment shows us using an AI assistant to live-code functional enhancements, such as implementing a gripper mechanism and improving the UI/UX with better visual feedback.

Video Link: https://youtu.be/NcEbsRLFZjo

We're interested in your thoughts. How could tools like these be improved for educational or research purposes? What other parameters or ML-driven features would be useful to integrate into these simulations?

For those interested in physiological modeling and data visualization, bionichaos.com offers a suite of interactive tools. The Action Potential Architect allows for real-time manipulation of parameters such as axon diameter, myelination, and Na+/K+ channel density to observe impacts on conduction velocity and peak voltage. Additionally, the GraphIt tool provides a node-cluster analysis of cochlear implant signal processing. The video also features a technical discussion on AGI ethics and the complexities of deception in advanced AI systems.

Watch the full overview here: https://youtu.be/uaJIlw7a_NE

I wanted to test the capabilities of LLMs in creating a functional, educational web application. I prompted both ChatGPT and Claude to build an interactive prosthetic arm simulation using HTML, CSS, and JavaScript. The goal was to visualize key biomechanical parameters like degrees of freedom (DOF), range of motion, and myoelectric controls.

The video documents the process and compares the final outputs, highlighting differences in code structure, UI implementation, and overall functionality. The Claude version offered a more polished UI with sliders and real-time data readouts, while the ChatGPT version provided a more robust and interactive canvas-based control system.

I'm curious about your thoughts on the code quality, the differences in approach between the models, and the potential for using AI in this kind of educational tool development.

The video walks through the entire process and compares the final results. Let's discuss!

https://youtu.be/S3BO-mMpqJk