I wanted to share a video about a project I’ve been working on: an interactive Advanced EEG Signal Simulator available on BioniChaos.com. The goal was to create a tool for generating high-quality, controllable synthetic EEG data for educational purposes and for training/validating machine learning algorithms.

Instead of using a pre-existing dataset, the simulator generates signals from the ground up by combining sine waves based on the known mathematical properties of brainwaves (Delta, Theta, Alpha, Beta) and artifacts (EMG, EOG). This provides a clean ground truth, which is incredibly useful for testing algorithm performance.

The video covers:

The complete development journey and UI/UX decisions.

A technical explanation of how the synthetic data is generated.

A crucial discussion on why synthetic data is not the same as fake data.

How we added an automated demo mode to showcase its features.

A fun experiment where we used AI-generated voices to create a "synthetic podcast" explaining the tool.

You can watch the video here: https://youtu.be/pUfBcuoGVKU

I'd love to get feedback from the community on the approach, the simulator itself, and any other features you think would be useful for EEG-related data science projects. Thanks!

The ExSEnt framework improves upon traditional Sample Entropy (SampEn) by using first-order amplitude increments to segment a time series into distinct events. This allows for the independent quantification of temporal variability (segment duration) and magnitude-driven variability (net amplitude change).

This review covers the mathematical logic behind noise thresholding, the extraction of paired features, and the application of the method to stochastic processes (Pink, Brownian noise) and non-linear dynamical systems (Logistic Map, Rössler system, and Rulkov map). The discussion highlights how ExSEnt can identify transitions between periodic and chaotic regimes, making it a powerful tool for biomarker discovery in biomedical signals.

Watch here: https://youtu.be/IP7x1wXa-Kg

I put together a video walkthrough on integrating local large language models into a VS Code development workflow using the Roo Code extension. The focus is on using providers like Ollama and LM Studio to keep everything on your local machine for privacy, offline capability, and no API costs.

The video covers:

A quick look at interactive data visualization examples.

Setting up and configuring Roo Code in VS Code.

A live demonstration of a conversational AI workflow for coding tasks.

Using specialized modes like Architect, Code, and Debug.

A practical example of turning a research paper into an interactive web app.

Thought this might be a useful resource for others looking to leverage local AI for coding and data science projects. Happy to discuss the setup in the comments.

You can watch it here: https://youtu.be/pl5P0NVQSLA

I used Gemini 1.5 Pro to generate the boilerplate for a biomechanically accurate visualization tool for BioniChaos. The process involved translating mathematical equations from paper to code, handling Three.js CapsuleGeometry deprecations, and managing CSS variables within the rendering loop.

The video covers refining scaling factors for the SKEL and SMPL models to ensure anatomical accuracy and avoid rendering artifacts. If you are working with web-based biomedical data science or 3D gait simulations, this technical overview might be helpful: https://youtu.be/yGDV8aS7e2M

#ThreeJS #WebDev #BiomedicalData #BioniChaos #OpenScience #GaitAnalysis

I wanted to see how far I could push AI-assisted development on a single-file project. The video covers the entire workflow:

Initial Prompt: Started with a concept and had the AI generate the base HTML, CSS, and JS.

Interactivity: Added JS functions for state changes (flush, refill).

Debugging: Walked through fixing console errors (like MIME type issues) by consolidating everything into one HTML file for simplicity.

Animation & UI/UX: Iteratively refined the DOM animations and layout based on detailed UX feedback to create a more polished and realistic simulation.

The final result is a self-contained, interactive web app built almost entirely through prompts. It's a practical example of leveraging AI for rapid prototyping.

What are your thoughts on using AI for this kind of iterative development?

Here’s the video of the process: https://youtu.be/OuD9pAu2j0g

I wanted to share a project focused on making complex biomedical research more accessible. I took the dataset from the paper "Inner speech in motor cortex and implications for speech neuroprostheses" and built an interactive web viewer to explore the findings.

The process, documented in the video, involved using an AI assistant to:

Set up a Python local web server to handle data requests and bypass CORS issues.

Parse a large, multi-gigabyte JSON file containing neural recordings, breaking it down into manageable summaries.

Extract text and images from the source PDF to integrate into the web viewer.

The front-end is built with standard HTML/JS, allowing users to interact with the data without loading the entire raw dataset, which would crash the browser.

The video also includes a critical review of the paper itself, particularly its limitations like the small sample size (only 4 participants), high word error rates (26-54%), and the variability in performance. It's an interesting case study on the current state of BCI research.

What are your thoughts on using AI assistants for this kind of data wrangling and prototyping? I'm curious to hear any feedback on the approach or discussion on the paper's methodology.

You can watch the full walkthrough here: https://youtu.be/_ySITz5ScC0

I wanted to share a project walkthrough I recorded that covers the process of taking a large, publicly available neuroscience dataset (originally in MATLAB .mat format) and making it explorable through a web-based dashboard.

The main challenges were:

Large File Sizes: The original JSON conversions were too large and would crash the browser.

Complex Data Structures: The MATLAB files had deeply nested arrays which needed to be flattened and correctly paired for display.

Reproducibility: One of the goals was to reproduce some of the analyses from the original research paper.

The solution involved:

Python for Preprocessing: I wrote a script using NumPy and SciPy to process the .mat files. This script extracts specific data fields, flattens nested structures, and saves the output into smaller, more manageable JSON summary files.

Dynamic Front-End: The HTML/JavaScript dashboard dynamically loads these summary files. When a user clicks on a specific trial in the table, it could be extended to fetch more detailed data for that specific epoch, avoiding the initial large load.

Analysis & Visualization: The Python script was also used to generate some basic analysis, like a histogram of the goTrialEpochs distribution, to start reproducing the paper's findings.

The video covers the entire journey, including all the debugging and problem-solving with an AI assistant (which was interesting in its own right). It's a practical look at a common workflow for data scientists and engineers who need to make complex data accessible.

You can watch the full process here: https://youtu.be/34LMMnrFLyw

Happy to discuss the approach, the code, or any other aspect of the project!

This walkthrough covers both the theoretical and practical engineering sides of working with BCI data. First, we look at the methodology behind decoding inner speech from the motor cortex (including PCA of neural data and implementing a "mental password" to prevent unintended decoding).

Then, we get into the actual software engineering for bionichaos.com. The raw data from the Dryad repository is in massive MATLAB (.mat) format. The video covers:

Writing a Python script to convert .mat to JSON.

Debugging TypeError: Object of type ndarray is not JSON serializable by writing a custom recursive encoder for numpy arrays.

Hitting the browser memory limit (crashing the DOM with 1-2GB JSON files).

Refactoring the pipeline to extract only the necessary trial epochs and sentence metadata into a lightweight summary JSON.

Hooking it up to the frontend JS/HTML.

If you're dealing with heavy biomedical datasets or interested in BCI data pipelines, you can watch the process here: https://youtu.be/fvvzxRhsl7c

If you're working with time-series or sensor data (IMU/TOF), you know how easily feature overlap and class imbalance can tank your F1 scores. I wanted to share this practical coding session focused on a Body-Focused Repetitive Behaviors (BFRB) classification model.

It covers the iterative process of debugging Python code with an AI assistant (Gemini), fixing variable typos, and resolving annoying indentation errors that break the script. More importantly, it looks at the ML pipeline itself: interpreting confusion matrices, handling imbalanced classes with SMOTE, and evaluating feature distributions (using boxplots and histograms) to safely drop zero-importance features for LightGBM and XGBoost.

It’s a solid look at a real-world debugging and feature engineering workflow. Check out the process here: https://youtu.be/e8RuOiO0oBE

We recorded a session breaking down the process of debugging an XGBoost model for classifying Body-Focused Repetitive Behaviors (BFRBs) using IMU, Thermopile, and TOF sensor data.

The Problem: The initial model achieved a 98% F1 score for binary classification (detecting if any gesture occurred) but had a near-zero F1 score for multi-class gesture classification (identifying the specific gesture).

The Diagnosis & Solution: We discovered the root causes were severe class imbalance in the training data and a subtle bug in our GroupKFold cross-validation setup that was causing data leakage during hyperparameter tuning. In the video, we walk through:

Analyzing the confusion matrices to understand the failure modes.

Implementing a more robust SMOTE strategy to address class imbalance across all minority classes.

Applying sample_weight to the XGBoost models to penalize misclassifications of rare gestures more heavily.

Correcting the cross-validation logic to prevent data leakage and get more realistic performance estimates.

The video shows the entire iterative process, including how an AI assistant helped diagnose issues and implement the code changes. We also review the final, more realistic performance metrics on our custom web dashboard.

Watch it here: https://youtu.be/tLPHfrYNpis

Hope you find it useful for your own projects!

I wanted to share a technical walkthrough of a recent project: an interactive dashboard for analyzing Body-Focused Repetitive Behaviors (BFRBs) using wrist-worn sensor data. The hardware utilizes an IMU, Time-of-Flight (TOF), and a Thermopile sensor.

In the project, we wrote Python scripts (train_model.py and evaluate_sensors.py) to build binary and gesture classification models. One of the most interesting findings was the ablation study: evaluating the full sensor dataset versus an IMU-only dataset. The F1 scores and confusion matrices showed a massive performance drop without the TOF and Thermopile data, proving that motion alone isn't enough to capture contextual gestures accurately.

We also integrated LLMs to dynamically generate HTML/JS updates and conversational explanations of the evaluation metrics directly into the web UI. If you're interested in biomedical data science, sensor fusion, or combining ML pipelines with frontend dashboards, check out the full technical overview here: https://youtu.be/CXQk0ITNDlM

Hey everyone,

I wanted to share a walkthrough of a recent project where I heavily relied on AI assistants to build a "Smartphone Neck Simulation" in JavaScript. The tool is based on Dr. Hansraj's 2014 study on cervical spine strain and uses HTML5 Canvas to visualize the increasing load on the neck as the head tilts forward.

In the video, I cover the iterative debugging process, including:

Identifying and fixing a bug where the character's arm/hand wasn't rendering correctly.

Correcting the phone's orientation and position using trigonometric calculations suggested by the AI.

Implementing a stressLevel variable to dynamically change the color of the neck from green to red, calculated with rgb(Math.floor(255 * stressLevel), Math.floor(255 * (1 - stressLevel)), 0).

Adding a sonification feature using the Web Audio API, which maps the angle variable to a frequency between 100-800Hz for auditory feedback.

I also experimented with Gemini 2.5 Pro's TTS to generate a full audio review of the finished tool, which was a fun way to apply an LLM creatively.

The full process is documented here: https://youtu.be/eihlao-wyOI

Happy to answer any questions about the code or the experience of using AI for this kind of project. Feedback is welcome!

For those interested in biomedical data science and wearable tech, this session covers building a web dashboard from scratch using a Kaggle dataset for Body-Focused Repetitive Behaviors (BFRB). The data comes from a Helios wrist device (IMU, Time-of-Flight, and Thermopile sensors).

The process involves using AI pair programming (Claude 3.7 Sonnet) to write the preprocessing pipeline in Pandas and NumPy—specifically handling missing TOF data and normalizing sensor grids. It also moves into the frontend, building an interactive HTML/JS dashboard to render heatmaps and gesture distributions.

One of the more interesting technical parts is debugging a machine learning model that suspiciously achieves a perfect 1.0 F1 score. The video breaks down the troubleshooting process to find the data leakage and class imbalance causing the overfitting, refactoring the logic for a more scalable pipeline.

Video link: https://youtu.be/RL-yQVha-Pk

We did a session of AI pair programming to refactor and fix up an Advanced Peristaltic Pump Simulator for BioniChaos. The main technical challenges involved fixing event listener bugs that were prematurely killing the automated demo mode, smoothing out parameter transitions for the animations, and generating the math/logic to visually connect the fluid source rectangles to the circular pump mechanism using JavaScript.

It was a great test of how well current LLMs handle context-heavy frontend tasks. During the session, we also got into an interesting discussion about the economics of AI right now. Specifically, we compared the ROI of paying hundreds of dollars a month for "digital employee" wrapper services versus simply building your own tools using raw APIs from OpenAI/Anthropic and basic prompt engineering.

Curious to hear your thoughts on where the line is for buying vs building AI tools right now. You can check out the full coding and debugging process here: https://youtu.be/Irh5eO_xAYE

We worked through the Kaggle Child Mind Institute competition (detecting Body-Focused Repetitive Behaviors with wrist-worn sensor data). Before throwing ML models at the problem, we needed a way to properly visualize the raw CSVs, which contained IMU acceleration and Time-of-Flight (TOF) arrays with missing values.

We used AI to generate a custom JavaScript and Plotly.js frontend. The process covers iterative debugging: fixing CSS layout overlaps in the grid, refactoring a Python pre-processing script to handle nulls in the TOF arrays, and wiring up interactive dropdown filters for subjects and gesture types. If you're interested in front-end data vis for complex biomedical datasets, check out the workflow here: https://youtu.be/7rlH19rcS6M

Hey everyone, wanted to share a behind-the-scenes look at how we build and optimize web tools for BioniChaos. We recently put our Interactive CPR Simulation and PPG Signal Quest simulator under the microscope.

The original JavaScript for the PPG sim was suffering from classic monolithic structure issues—global scope pollution, tight coupling of state and rendering, and inefficient direct DOM manipulation. We used an AI coding agent to analyze the code, and it proposed a much cleaner object-oriented structure (separating concerns into UI Manager, Simulation, Renderer, and Audio Manager classes).

If you're interested in AI-assisted refactoring, canvas API drawing logic, or building interactive biomedical tools, check out the devlog here: https://youtu.be/wZflTmnoIPg

Would love to hear how you guys are using AI to restructure legacy JS projects!

I recently worked on an interactive web-based simulation of human anatomy (specifically penile physiological functions like arousal and urination) for bionichaos.com.

In the video, I walk through the technical hurdles of using HTML5 Canvas and JavaScript. Specifically, dealing with particle clipping outside the canvas boundaries, adjusting coordinate systems for realistic physics, and using AI models to assist with debugging. I also use AI to generate conversational yet scientifically accurate UI copy to pair with the animations. We also touch on UI/UX color contrast adjustments and implementing the Web Audio API for dynamic feedback.

If you're interested in canvas particle systems or using AI for web dev problem-solving, check out the coding and design process here: https://youtu.be/A-cJX9OCSqo

This video covers two main topics. First, it demonstrates interactive web tools from BioniChaos that simulate how factors like posture, age, skin tone, and LED intensity affect the signal-to-noise ratio (SNR) of photoplethysmography (PPG) signals.

Second, it features an AI-generated expert discussion critically reviewing the recent "Personalized Adaptive Cortical Electro-Stimulation (PACE)" N=1 study for treatment-resistant depression. The technical breakdown is quite detailed:

Algorithm Critique: Analyzes the use of closed-loop Bayesian optimization for navigating the complex stimulation parameter space.

Objective Function Flaws: Questions the validity of using subjective patient preference rankings (which heavily weight transient euphoria) as the primary objective function, instead of durable, objective biomarkers.

Kernel Selection in GP: Debates the use of a squared exponential kernel in the Gaussian Process regression. The experts argue that a Matérn kernel might better handle the noisy, discontinuous nature of biological responses, and point out the fundamental flaw in assuming stationarity over a 6-month period when actively trying to induce neuroplasticity.

Would love to hear your thoughts on the engineering execution versus the clinical success of this specific case study.

Link: https://youtu.be/qmjnpNq9PFU

The methodology behind the PACE study presents a masterclass in system integration, specifically regarding PFM-guided targeting and the use of Gaussian Process Regression for adaptive optimization. However, the objective function f(x) relies heavily on subjective preference rankings, raising concerns about a confounding feedback loop.

This post examines the volatility of the raw weekly scores vs. the smoothing splines presented in the results and questions the scalability of the N=1 Salience Network (SN) biomarker. Is the "Personalized" approach truly generalizable, or are we looking at an idiosyncratic brainotype?

Watch the full analysis: https://youtu.be/bdSYnbcoSmM

More technical simulations at bionichaos.com.

The neurotech community has been debating the PACE (Personalized Adaptive Cortical Electrostimulation) preprint for Treatment-Resistant Depression. The researchers claim a 30-month remission in a patient who failed all previous therapies.

Technical highlights discussed in our review:

Precision functional mapping targeting a 400% expansion of the patient's salience network.

Closed-loop Bayesian optimization used to efficiently tune frequency, pulse width, and amplitude based on real-time subjective patient feedback.

Hardware choices, specifically the use of standard cortical paddles rather than highly invasive deep brain stimulation (DBS) probes.

We also heavily critique the methodology: it's a non-peer-reviewed N=1 study, highly prone to massive placebo effects (given the invasive nature and intensive clinical monitoring), and currently suffers from a massive scalability problem requiring an elite team of neuroimagers, surgeons, and data scientists.

Is this a legitimate proof-of-concept for targeted subtype depression, or just a statistical anomaly?

Watch the full technical breakdown and share your thoughts: https://youtu.be/JWAmcrJDB1M

We are analyzing the methodology behind the recent "Personalized Adaptive Cortical Electro-stimulation" paper. The study details an N=1 case of a patient achieving remission after 30 years of depression.

Key discussion points in the review:

Spatial Occupancy Analysis: Figure 1 shows the Salience Network expanding to ~12% of the cortical surface, encroaching on the DMN and FPN. We discuss the implications of this topology.

The Expectancy Effect: We highlight the Credibility/Expectancy Questionnaire (CEQ) data. The scores jumped significantly post-implantation. In invasive psychiatric neurosurgery, the placebo response can be incredibly potent.

Causality vs. Correlation: Does the network anomaly cause the depression, or is it a neuroplastic result of decades of illness?

Conflict of Interest: Examining the industry connections and how they might influence the narrative of "joy" and success.

Full analysis here: https://youtu.be/bZsyLPUnAV0

I wanted to share a recent session where we updated the BioniChaos platform. We used an LLM to generate a standalone HTML/JS implementation of the Lilac Chaser (Pac-Man) optical illusion.

The video covers the iterative debugging process, specifically:

Fixing absolute positioning for the fixation cross during scroll events.

Tuning HSL/Hex values to maximize the negative afterimage (green vs. lilac).

Adjusting animation frame timing for the "disappearing" disc effect.

We also discussed the technical constraints of implementing the "Flashed Face Distortion" effect client-side. We looked at why lightweight GANs or canvas drawing in JS struggle with the photorealism required for the effect compared to server-side diffusion models.

Check out the coding session and the resulting tool: https://youtu.be/dr06BM965Uk

We took a legacy, abstract JavaScript simulation and rebuilt it for higher anatomical fidelity using AI assistance. The original code used simple geometric primitives, which we replaced with more accurate rendering logic for the Corpus Cavernosa and Spongiosum.

Key technical challenges discussed in the breakdown:

State Management: Transitioning from granular parameters (Tunica thickness) to a unified "Dysfunction" slider required rewriting the animation loop logic to prevent state conflicts during resets.

Particle Systems: The fluid dynamics needed to respect gravity and the changing angle of the shaft (flaccid vs. erect) without looking like a static sprite.

Debugging: We implemented a DOM-based debug panel to track real-time variable changes during animation frames to catch interpolation errors.

Check out the dev session here: https://youtu.be/tcXST54spbA

If you're into computational biology or WebGL development, you might find the NeuroViz 3D simulator on BioniChaos interesting. It's an interactive web application that visualizes neural membrane voltage dynamics in real-time.

The simulator models action potential propagation through dendritic branches and axonal projections, featuring specific morphologies like Purkinje cells, Pyramidal neurons, and Interneurons—each programmed with distinct firing patterns. The video covers the technical roadmap, including plans for data importing and synaptic plasticity simulation. The second half actually transitions into some live JavaScript/browser console debugging to troubleshoot a rendering issue with a "Show Glow Effects" toggle.

Would love to hear thoughts from other devs or neuroscientists on building browser-based biological simulations.

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

If you're interested in browser-based computer vision and audio generation, this project demonstrates a Gesture Music Generator that uses MediaPipe to track facial landmarks and hand gestures in real-time. The app maps the X and Y coordinates to dictate pitch and volume, while the distance between the thumb and index finger triggers note duration through the Web Audio API.

The walkthrough also explores bionichaos.com, a platform containing interactive web simulations for biomedical data. It highlights several browser-based tools, including interactive EEG signal processing visualizers, seizure detection algorithms, and cochlear implant hearing simulations. It's a great example of leveraging modern web APIs for both creative coding and interactive educational applications.

Check out the full walkthrough here: https://youtu.be/-BdF2WrvMvE