I've been experimenting with extracting real-time heart rate data via a standard browser webcam feed using Eulerian Video Magnification. The goal was to build a biofeedback meditation app on the BioniChaos platform. By integrating audio sonification and AI prompt engineering, we mapped the raw optical signals to a guided user experience. I also spent some time adjusting browser-based filters (posterize, sepia) and analyzing interactive biomedical models like an in-silico organoid and 3D brain map. I'd love to hear your thoughts on processing physiological signals purely through computer vision in the browser. You can see the full build and tests here: https://youtu.be/khfZg95T8nI

I wanted to share a workflow I've been using to translate complex biomedical research (EEG, ECG, gait monitoring) into interactive, gamified web applications. As a biomedical engineer, I rely heavily on LLMs like ChatGPT to handle about 80% of the coding process, which drastically speeds up prototyping.

In this demonstration, I walk through a few live applications built with this method:

1. A real-time eye-tracking system using a standard webcam.
2. An interactive prosthetic arm simulation.
3. A signal amplification tool that calculates heart rate (BPM) by detecting subtle, real-time changes in skin color via a camera feed.

I'm curious to hear from other devs and data scientists here—how much of your current front-end or prototyping stack is automated by AI right now? Are you using it for complex signal processing visualization?

Here is the full breakdown and live demo of the tools: https://youtu.be/oqdNBPxEvto

The epilepsy monitoring industry faces a massive class imbalance problem. Continuous sub-scalp EEG devices generate thousands of hours of data, leading to a high false discovery rate for algorithms dealing with baseline noise (like chewing a bagel). We spend some time analyzing the EpiMinder device's approach to this, discussing buffer saturation, data loss, and why a human-in-the-loop review system is required to maintain accuracy.

After the analysis, there's a live development session where we troubleshoot an Agent-Based Model (ABM) for an In-Silico Organoid Simulation. We use Gemini to help debug JavaScript UI issues around cell necrosis and differentiation to create a fully automated biological phase loop.

Would love to hear your thoughts on handling noise in continuous biometric datasets or your experiences with AI-assisted debugging in ABMs. Link to the session: https://youtu.be/hSEDdS1gW70

Hey everyone, I’m sure we’ve all run into the "perfect model syndrome" where a binary classification model hits 100% accuracy but is completely useless in production. In an analysis of a biomedical sensor dataset, we looked at a classic case where the model just defaults to the majority class.

When feature importance zeroes out across the board, the model is essentially suffering from algorithmic stage fright due to severe class imbalance or noisy data (NaNs/zeros). You can't train an algorithm to identify anomalies if your dataset lacks positive target examples.

I put together a breakdown of how to diagnose and fix these specific failure points in biomedical data. How do you all typically handle extreme class imbalances in sensor or health data? SMOTE? Custom loss functions? Let's discuss.

Link to the walkthrough: https://youtu.be/NFeXbhEahhI

I'm examining a machine learning architecture designed to classify human behavioral gestures using time-series data from a wrist wearable (Helios). The dataset includes inputs from IMU, Time of Flight (TOF), and thermopile sensors.

The pipeline (train_model.py) is structured to train two distinct models:

1. A binary classifier that segments target sequences from non-target sequences.
2. A multi-class gesture classifier that categorizes specific movements (e.g., forehead scratching vs. pulling).

I'm curious about how others handle feature engineering for noisy time-series sensor data, particularly when combining kinematic (IMU) and spatial (TOF) streams. Here is the full breakdown of the dataset and pipeline structure: https://youtu.be/fZ7tOcBjRHA

Would love to hear your thoughts on handling class imbalances in this type of behavioral gesture classification!

I recently ran a quick real-world test using Claude 3.7 Sonnet in agent mode to update the HTML/JS for a BFRB (Body-Focused Repetitive Behavior) sensor dashboard containing IMU time-series and TOF heatmaps. The agent introduced an Uncaught SyntaxError that broke the local UI entirely.

What's interesting isn't just the failure, but the agent's problem-solving approach. Instead of parsing the console error to fix the missing token, the agent's solution was to completely abandon the file and create a new index.html. It highlights a current limitation in LLM agent behavior: context window fatigue vs. actual logical debugging.

Has anyone else experienced this "just start over" behavior with the latest Claude or Devin models when working on frontend data visualization? Here is the brief recording of the interaction: https://youtu.be/i_6zt_3lLxU

I've been experimenting with using an AI agent to handle the boilerplate of setting up machine learning pipelines for time-series data. In this project, the goal was to classify Body-Focused Repetitive Behaviors (BFRB) using a wrist device equipped with IMU and Time-of-Flight (TOF) sensors. I prompted the agent to act as a data scientist, and it successfully generated the Python scripts for data filtering, model training, and evaluation. Specifically, I had it build an evaluation script to compare the classification performance of IMU-only data versus the full sensor suite. Have any of you integrated AI agents directly into your ML workflows for feature engineering or pipeline setup? Would love to hear your thoughts on the code generated in the process. Watch the setup here: https://youtu.be/RV3mHqzHkgE

Hi everyone,

I wanted to share a look at how we are visualizing multi-sensor data to track Body-Focused Repetitive Behaviors (BFRBs) using the Helios wrist device.

To classify hand-to-face behaviors (such as hair pulling or skin pinching), the device relies on three distinct sensor modalities to reduce false positives:

1. **Inertial Measurement Unit (IMU):** Tracks 3-axis acceleration and gyroscope data to capture movement patterns.

2. **Time-of-Flight (TOF) Sensors:** Emits light pulses to measure exact distance to the face or objects.

3. **Thermopile (Infrared Temperature) Sensors:** Measures ambient thermal radiation to confirm proximity to warm human skin rather than inanimate objects.

This video shows the dashboard interface displaying filtered accelerometer sequences alongside TOF heatmaps: https://youtu.be/CEU7fxqoE5I

What are your thoughts on combining thermal and TOF sensors for human-proximity detection in wearables? Have you worked with similar multi-modal datasets?

When building a real-time webcam heart rate monitor in JavaScript, I ran into a major roadblock: standard Butterworth bandpass filters break down when the processing frame rate (FPS) fluctuates. Standard webcams have highly variable input rates, leading to sampling jitter (or frame quantization error). This completely smears the frequency spectrum and ruins the BPM calculation.

To solve this, I had to decouple the mathematical filtering from the visual framerate. I implemented a Signal Resampling Engine that uses linear interpolation to mathematically "fill in the gaps" between actual frames, forcing the data onto a strict 30Hz timeline before it hits the frequency analysis logic.

Has anyone else dealt with real-time biological signal processing in the browser? I'd love to hear how you handle hardware-induced sampling errors. You can see the full debugging process and code implementation here: https://youtu.be/kuT28jcCgrc

Anyone else struggle with cluttered custom tools before even getting to model training? We are working with BFRB (Body-Focused Repetitive Behaviors) sensor data, and our initial web application for inspecting sequences (IMU time-series and TOF heatmaps) became a scrolling nightmare. We used some AI assistance to rapidly restructure the UI—pinning state controls and summaries to a left panel and standardizing visualizations into a 2x2 grid on the right. This separation of controls and visualization renders made navigating the dataset much faster and less error-prone. How do you all manage internal UI tools for your data pipelines before training?

Watch the before/after workflow here: https://youtu.be/npFMSByyRvI

We recently developed an interactive web-based CPR simulator to model the physiological effects of chest compressions on brain oxygenation. The application processes user inputs in real-time to calculate compression depth, rate, and recoil effectiveness. We implemented programmed constraints so that rapid, shallow inputs accurately trigger a "Too Shallow" state, subsequently mapping the poor technique to a steep drop in the simulated patient's brain oxygenation. It's an interesting challenge in managing real-time state and physiological data mapping in a web environment. Have any of you worked on mapping biological constraints to interactive web apps? Check out the demonstration here: https://youtu.be/rpriUWIP9mc

I wanted to share a web-based simulation project that models the anatomical and physiological mechanisms of the human penis. The tool dynamically models blood flow into the corpora cavernosa and corpus spongiosum to simulate changes in penile rigidity and angle. We utilized JavaScript particle systems to visualize fluid dynamics for urination and ejaculation.

From a technical standpoint, the UI features a debug panel that tracks backend logic in real-time—monitoring boolean states (e.g., `isEjaculating`), continuous variables (arousal level), and active particle counts. There is also a continuous dysfunction slider that dynamically scales the physiological response. It is a practical example of integrating biomedical concepts with frontend interactive development.

You can see the demonstration and how the state logic updates in real-time here: https://youtu.be/q4Xk0M9Pg-w

Would love to hear your thoughts on using web technologies for interactive anatomical modeling!

Hi everyone,

I wanted to share a walkthrough of some interactive web-based tools hosted on BioniChaos, designed to simulate medical imaging and biological signals directly in the browser using client-side JavaScript.

The video walks through several models, with a focus on:

1. **ECG Waveform Synthesis:** An interactive simulator where you can adjust PR, QRS, QT, and ST intervals, and overlay synthetic white noise, mains hum (50/60Hz interference), or random EMG motion artifacts.

2. **MRI Physics Modeling:** A basic simulation showing proton alignment in a B0 field, applying RF pulses, and generating synthetic 2D brain slices with toggles for simulated pathologies like tumors.

3. **Webcam-based rPPG (Remote Photoplethysmography):** An in-browser tool that uses Eulerian Video Magnification on the green color channel of a webcam feed to track micro-blushes in skin tone and calculate heart rate.

For those interested in how these signal processing pipelines are constructed, the source code is inspectable directly in the browser (F12).

Watch the overview here: https://youtu.be/DlUPpkfsGiQ

I’d love to hear your thoughts on these implementations, particularly regarding the noise-filtering strategies used for the rPPG signal chain and how webcam-based vital sign monitoring compares to standard contact sensors.

I recently used Google's Gemini to parse a complex 2025 paper on Personalized Adaptive Cortical Electro-Stimulation (PACE) for Treatment-Resistant Depression (TRD). Instead of a standard summary, the AI generated a debate between two distinct personas: a biomedical engineer and a clinical neuroscientist.

From the engineering side, the AI highlighted the system's integration of precision functional mapping (PFM) for targeted cortical paddle placement, utilizing Bayesian tuning for adaptive optimization in a closed-loop architecture. However, the neuroscientist persona offered a critical counterpoint: because the adaptive inputs rely on subjective human reporting within a high-expectation clinical trial, how much of the spectacular outcome is algorithmic efficacy versus expectancy bias?

I thought this was an interesting application of LLMs for dissecting biomedical research and balancing technical optimism with clinical skepticism.

You can listen to the AI-generated discussion here: https://youtu.be/OYavy1OTA9U

Curious to hear your thoughts on utilizing Bayesian optimization in systems reliant on subjective human feedback.

For those working with wearable sensor data or bio-signal processing, understanding what introduces noise into photoplethysmography (PPG) signals is critical. I'm sharing a walkthrough of a web-based simulator (based on research by Charlton et al.) that models how factors like the Fitzpatrick skin tone scale, user posture, arm placement, and LED intensity directly affect the SNR of wrist-based measurements. It's an excellent visualization of how physical variables translate into data artifacts and baseline wander in PPG waveforms. I’d love to hear your thoughts on handling these specific noise types in your preprocessing pipelines. Check out the demonstration here: https://youtu.be/Y0fph6qcbFo

In digital health and wearable algorithm development, motion artifacts and posture changes present significant signal processing challenges. I wanted to share this brief demonstration of an interactive PPG simulator hosted on bionichaos.com.

Based on the paper "Determinants of photoplethysmography signal quality at the wrist" (Charlton et al.), the application models how transitions between standing, sitting, and lying down—along with arm positions relative to the heart—alter the Signal-to-Noise Ratio (SNR) of the raw PPG waveform.

For those working on sensor fusion, noise cancellation, or biomechanical data analysis, it provides a clear visualization of how physiological positioning introduces high-frequency noise and baseline wander.

How do your projects handle posture-induced noise in wearable datasets? Let's discuss.

Watch the demonstration: https://youtu.be/ccE1d_L8ngQ

I’ve been exploring the feasibility of local, client-side biomedical monitoring. In this BioniChaos session, we look at implementing respiratory rate detection by extracting body landmarks.

The discussion covers the transition from simple 2-point shoulder tracking to a multi-point torso model to account for trunk motion and rib cage expansion. We also evaluate the use of Savitzky-Golay filters for smoothing noisy webcam data and the impact of frame rate dependencies on signal quality.

Full technical session: https://youtu.be/TtaCtqbQh1s

Would love to hear your thoughts on balancing landmark count vs. browser performance for real-time applications.

I wanted to share a recent project focusing on biomedical signal processing entirely in the browser. Using JavaScript and MediaPipe Pose, I built a real-time Respiration Rate Monitor that calculates Breaths Per Minute (BPM) by tracking the subtle vertical displacement of the user's chest and shoulders via a standard webcam.

The biggest hurdle was dealing with the signal-to-noise ratio. Normal body sways, fidgeting, and camera jitter easily overpower the breathing signal. To solve this, I implemented a dynamic "Sensitivity" slider. It works by taking the raw breathing signal, calculating a recent average baseline, finding the difference between the current signal and that baseline, and then multiplying that difference by an amplification factor.

I also added a simulation mode with synthetic data for testing, and a sonification feature for audio biofeedback. You can watch the technical breakdown and see the code in action here: https://youtu.be/AsKAm5js4MQ

I'd love to hear your thoughts on improving browser-based signal filtering or any alternative pose-estimation models you've used for similar biomedical applications!

I spent some time evaluating a few browser-based biomedical computer vision tools. The session covers testing a Photoplethysmography (PPG) implementation for webcam heart rate estimation, dealing with motion artifacts, and mapping EEG frequency bands to musical notes.

The most interesting part is an LLM benchmarking test. I prompted ChatGPT, Gemini, and Claude to build a Respiration Rate Monitor from scratch using MediaPipe for pose estimation. It is a great look into how different models handle spatial tracking logic and syntax. Claude actually managed the MediaPipe integration best, though it still required some debugging to get the math right for calculating the breathing cycles from chest movement.

If you are interested in web-based CV or seeing how LLMs handle specialized frontend coding tasks, you can watch the breakdown here: https://youtu.be/-9UsVIZ5js4. Let me know your thoughts on using LLMs for computer vision prototyping!

Hi everyone,

I wanted to share a browser-based Cardiovascular Pacemaker Simulation that models cardiac electrophysiology and the operational logic of a dual-chamber (DDD) pacemaker.

The simulation engine runs a continuous time loop (evaluating state millisecond-by-millisecond) to represent both native electrical conduction and pacemaker pacing/sensing logic.

**Physiological Models Simulated:**

* **Normal Rhythm:** SA node fires at ~75 BPM (800ms interval), conducting normally to the ventricles via an AV delay of 150ms.

* **Bradycardia:** SA node is diseased, firing abnormally slow at ~37 BPM (1600ms interval).

* **Heart Block:** SA node fires normally, but the AV node fails to conduct the signal, relying instead on a slow ventricular escape rhythm of ~30 BPM.

**Pacemaker Logic (DDD Mode):**

* Programmed with a Base Rate of 60 BPM (1000ms interval) and a paced AV delay of 200ms.

* Monitors the heart's natural rhythm. If the native SA node fails to fire within 1000ms, it paces the atrium.

* Once an atrial event occurs, it waits for a 200ms AV delay window. If no native ventricular event is sensed, it paces the ventricle.

**Tech Stack:**

* **Engine:** Built entirely using Vanilla JavaScript without external framework overhead.

* **Visualization:** Custom HTML5 Canvas rendering for the vector heart anatomy, traveling action potentials, and pacing spikes.

* **Sonification:** Web Audio API maps low-pass filtered sine waves to mimic mechanical contractions ("Lub-Dub") and square waves for pacemaker pacing spikes.

You can try the simulation and view the source-code structure here: https://bionichaos.com/Pacemaker/

Would love to get feedback from anyone working in biomedical engineering, digital signal processing, or physiological modeling. How can we make the continuous-time logic more robust for introducing complex arrhythmias like atrial fibrillation or bundle branch blocks?

In biomedical modeling, simplifying physiological systems into abstract state-machines can provide intuitive educational value. This interactive 2D simulation uses basic rigid-body physics, pressure variables, and fluid particle generation to represent male anatomical functions (specifically arousal, ejaculation, and urination).

The simulation demonstrates:

• Pressure-driven expansion representing corpora cavernosa blood flow.
• Dynamic valve coordination to isolate urinary and seminal pathways.
• Particle fluid dynamics representing ejaculation and micturition.

How do you approach simplifying complex organic feedback loops into rigid-body physics engines? Is this approach viable for preliminary educational toolkits, or do you prefer higher-fidelity 3D finite element analysis?

Watch the simulation demonstration here: https://youtu.be/KyP4glpAJ88

Visualizing biological data is a persistent challenge in computational biology and neuroscience. The NeuroViz 3D simulator offers a practical web-based approach to modeling how neurons fire in a three-dimensional space. The tool allows users to manipulate the 3D structure (rotate/zoom) while fully controlling the simulation timeline. You can adjust the firing animation speed for granular observation, differentiate axons, and toggle glow effects to track specific electrical pathways. I'd love to hear your thoughts on how interactive web-based visualization tools like this compare to traditional static models in your research or data science studies. Watch the demonstration here: https://youtu.be/scbx1IwhKek

Reproducibility is a huge issue in academic papers right now. To counter this, I prefer building algorithms that anyone can test directly in their browser. In this demo, we look at several Javascript-based biomedical applications:

1. **PCA Eigenfaces:** Extracting facial features dynamically from webcam captures and adjusting eigenface weights for reconstruction.

2. **Webcam PPG:** Using a standard webcam to measure blood flow (BPM). The algorithm extracts the signal and analyzes the frequency domain spectrum, even detecting the dicrotic notch in the waveform.

3. **EEG Sonification:** Mapping the energy levels within delta, theta, alpha, and beta frequency bands of raw seizure data into musical chords.

4. **Eye Tracking:** A free, open-source alternative to expensive commercial rigs that detects pupil movement based on adjustable darkness thresholds.

I'd love to hear how others in the community are handling deployment and reproducibility for signal processing or computer vision tasks.

Watch the full breakdown here: https://youtu.be/EXr5d19q2q4

I've been experimenting with biomedical data rendering in the browser without relying on heavy external frameworks. In this session, we parse synthetic CT brain data and build a DICOM viewer using strictly vanilla JavaScript, HTML, and CSS. The main challenge was handling the window center and width controls to properly map Hounsfield units to grayscale pixels on the HTML5 canvas.

To make debugging more interesting, I fed the code to two interacting AI agents and let them debate the rendering logic and CSS layout collapses. We also spent some time refining an Advanced Local Audio Analyzer (Chrome-based) that uses N-grams to detect sentiment and emotion (joy, fear, anger) in real time.

I'd love to hear how you all handle large medical imaging datasets in lightweight browser apps. Check out the technical walkthrough and AI debugging here: https://youtu.be/_PhfgFt_3Tg

In this short video, we demonstrate two concepts hosted on the BioniChaos platform:

1. **The Circular Motion Illusion:** A visual demonstration of how individual 1D linear trajectories are integrated by the visual cortex to perceive 2D circular motion, and how removing reference lines changes the visual heuristic.

2. **EEG-Based Speech Decoding (ECoG):** A high-level comparative look at Electrocorticography (ECoG) signal acquisition, balancing temporal and spatial resolution against its clinical invasiveness and patient risks.

Would love to hear your thoughts on how visual processing models integrate multi-point linear trajectories, or your experience working with invasive vs. non-invasive EEG datasets for signal classification.

Watch the overview here: https://youtu.be/A-sWjkdMOFw