DEV Community: Vu Hung Nguyen (Hưng)

The Mathematics and Engineering Behind 3D Heart Animations Synchronized with Music

Vu Hung Nguyen (Hưng) — Sun, 16 Nov 2025 06:34:50 +0000

The Mathematics and Engineering Behind 3D Heart Animations Synchronized with Music

Introduction

What happens when you combine parametric equations, audio signal processing, and real-time visualization? You get mesmerizing 3D heart animations that dance to music. This project started as a simple mathematical visualization and evolved into a comprehensive system for creating music-synchronized animations using Python, NumPy, Matplotlib, and librosa.

In this deep-dive, I'll walk you through the technical journey of building this system, from the mathematical foundations of the 3D heart shape to the audio engineering that makes hearts pulse in perfect sync with music.

Demo Videos:

The Key Ideas

At its core, this project solves three main challenges:

Mathematical Modeling: Creating a 3D heart shape using parametric equations
Audio Analysis: Extracting musical features (beats, tempo, loudness, bass, onsets) from audio files
Real-Time Synchronization: Mapping audio features to visual transformations in real-time

The magic happens when these three systems work together, each frame of the animation queries the audio features at that exact moment in time, creating a synchronized experience where the heart "feels" the music.

The Mathematics: Parametric Heart Equations

The 3D heart shape is defined by parametric equations using two parameters: u ∈ [0, π] and v ∈ [0, 2π].

The Core Equations

x = sin(u) · (15·sin(v) - 4·sin(3v))
y = 8·cos(u)
z = sin(u) · (15·cos(v) - 5·cos(2v) - 2·cos(3v) - cos(v))

These equations create a heart shape by:

Using sin(u) as a scaling factor that varies from 0 to 1 and back to 0
Combining multiple harmonics of sin(v) and cos(v) to create the heart's characteristic curves
The coefficients (15, -4, -5, -2, -1) control the shape's proportions

Implementation in Python

# Generate parameter grids
u = np.linspace(0, np.pi, u_points)
v = np.linspace(0, 2 * np.pi, v_points)
u_grid, v_grid = np.meshgrid(u, v)

# Flatten for scatter plot
u_flat = u_grid.flatten()
v_flat = v_grid.flatten()

# Apply parametric equations
x = np.sin(u_flat) * (15 * np.sin(v_flat) - 4 * np.sin(3 * v_flat))
y = 8 * np.cos(u_flat)
z = np.sin(u_flat) * (
    15 * np.cos(v_flat) +
    -5 * np.cos(2 * v_flat) +
    -2 * np.cos(3 * v_flat) +
    -1 * np.cos(v_flat)
)

3D Rotation

To rotate the heart around the Y-axis, we apply a rotation matrix:

alpha_deg = frame * 360 * tempo_factor / total_frames
alpha_rad = np.deg2rad(alpha_deg)

x_rotated = x * np.cos(alpha_rad) + z * np.sin(alpha_rad)
y_rotated = y  # Y-axis rotation doesn't affect Y coordinate
z_rotated = -x * np.sin(alpha_rad) + z * np.cos(alpha_rad)

The tempo_factor adapts rotation speed based on the music's tempo, making the heart rotate faster during upbeat sections.

The Sound Engineering: Audio Feature Extraction with Librosa

Librosa is a Python library for music and audio analysis. It provides the tools we need to extract musical features that drive our visualizations.

Audio Analysis Pipeline

The analyze_audio.py script performs a comprehensive analysis:

Beat Detection: Identifies the rhythmic pulse of the music
Tempo Tracking: Calculates BPM and tracks tempo changes over time
Onset Detection: Finds moments when new sounds begin
RMS Energy (Loudness): Measures overall volume over time
Bass Analysis: Extracts low-frequency energy

Beat Detection

tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)
beat_times = librosa.frames_to_time(beat_frames, sr=sr)

This gives us a list of timestamps where beats occur, which we use to make the heart pulse.

Dynamic Tempo Tracking

For longer pieces with tempo changes, we track tempo over time:

tempo_times, tempo_values = librosa.beat.tempo(
    y=y, sr=sr, 
    aggregate=np.median,
    hop_length=512
)

This creates a time series of tempo values, allowing the heart's rotation speed to adapt to tempo changes throughout the song.

RMS Energy (Loudness)

rms = librosa.feature.rms(y=y)[0]
rms_times = librosa.frames_to_time(range(len(rms)), sr=sr)
# Normalize to 0-1 range
rms_normalized = (rms - rms.min()) / (rms.max() - rms.min())

RMS energy measures the "loudness" at each moment. We use this to control camera zoom - louder sections bring the camera closer for a more intimate view.

Bass Extraction

# Extract bass frequencies (typically 20-250 Hz)
S = librosa.stft(y)
bass_freqs = np.where((freqs >= 20) & (freqs <= 250))[0]
bass_energy = np.sum(np.abs(S[bass_freqs, :]), axis=0)

Bass frequencies create the "thump" in music. We use bass strength to control the heart's brightness - more bass means a brighter, more glowing heart.

Onset Detection

onset_frames = librosa.onset.onset_detect(y=y, sr=sr, units='frames')
onset_times = librosa.frames_to_time(onset_frames, sr=sr)

Onsets mark the beginning of new musical events. Strong onsets trigger additional heartbeat pulses, creating visual emphasis on musical accents.

Output: JSON Feature File

All extracted features are saved to a JSON file:

{
  "beat_times": [0.1, 0.5, 0.9, ...],
  "tempo_times": [0.0, 0.5, 1.0, ...],
  "tempo_values": [120.5, 121.2, 120.8, ...],
  "rms_times": [0.0, 0.023, 0.046, ...],
  "rms_values": [0.3, 0.5, 0.4, ...],
  "bass_times": [0.0, 0.023, 0.046, ...],
  "bass_values": [0.2, 0.6, 0.3, ...],
  "onset_times": [0.15, 0.8, 1.2, ...]
}

This JSON file becomes the "score" that the animation follows.

Synchronizing Sound and Visuals

The synchronization happens in real-time during animation rendering. Each frame queries the audio features at that exact moment.

The Update Function

Every effect implements an update(frame) function that:

Calculates the current time: current_second = frame / fps
Queries audio features at that time
Applies transformations based on those features
Updates the 3D scatter plot

Audio Feature Queries

def get_beat_intensity(current_time, beat_times, window=0.1):
    """Returns 0-1 intensity based on proximity to nearest beat."""
    distances = np.abs(np.array(beat_times) - current_time)
    nearest_distance = np.min(distances)

    if nearest_distance < window:
        intensity = 1.0 - (nearest_distance / window)
        return float(intensity)
    return 0.0

This function checks if we're near a beat. If we're within 0.1 seconds of a beat, it returns an intensity value (1.0 = exactly on beat, 0.0 = far from beat).

Applying Audio Features to Visuals

# Heartbeat pulse on beats
heartbeat_scale = 1.0
if beat_intensity > 0:
    heartbeat_scale = 1.0 + 0.2 * beat_intensity  # Pulse 20% larger

# Apply scaling
x_rotated = x_base * heartbeat_scale
y_rotated = y_base * heartbeat_scale
z_rotated = z_base * heartbeat_scale

# Brightness responds to bass
alpha = 0.5 + 0.4 * bass  # More bass = brighter

# Zoom responds to loudness
zoom_factor = base_zoom - 3 * loudness  # Louder = closer

Each audio feature maps to a visual property:

Beats → Heartbeat pulse (scale)
Tempo → Rotation speed
Loudness → Camera zoom
Bass → Brightness/alpha
Onsets → Additional pulses

FFmpeg: Combining Video and Audio

Matplotlib's FFMpegWriter creates video-only files. We use FFmpeg to combine the video with the original audio track.

Video Generation

from matplotlib.animation import FFMpegWriter

writer = FFMpegWriter(fps=30, bitrate=5000)
anim.save('outputs/video.mp4', writer=writer)

This creates a silent video file with the animation.

Audio Combination

ffmpeg -i outputs/video.mp4 \
       -i inputs/audio.mp3 \
       -c:v copy \
       -c:a aac \
       -b:a 192k \
       -shortest \
       -y \
       outputs/final_video+audio.mp4

Key FFmpeg options:

-c:v copy: Copy video stream (no re-encoding, faster)
-c:a aac: Encode audio as AAC
-b:a 192k: Audio bitrate (192 kbps is good quality)
-shortest: End when shortest stream ends (syncs video and audio length)
-y: Overwrite output file without asking

Automated Workflow

PowerShell build scripts automate the entire process:

# Step 1: Analyze audio
python analyze_audio.py inputs/song.mp3

# Step 2: Generate video
python heart_animation.py --effect I2 \
    --audio-features song_features.json \
    --resolution large \
    --output outputs/video.mp4

# Step 3: Combine with audio
ffmpeg -i outputs/video.mp4 -i inputs/song.mp3 \
    -c:v copy -c:a aac -b:a 192k -shortest \
    outputs/final.mp4

Python and Matplotlib: The Visualization Engine

Matplotlib's 3D Scatter Plot

from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(width, height), dpi=dpi)
ax = fig.add_subplot(111, projection='3d')

# Create scatter plot
scatter = ax.scatter(x, y, z, c=colors, cmap='magma', s=1, alpha=0.8)

# Set view angle
ax.view_init(elev=30, azim=45)

# Set axis limits (controls zoom)
ax.set_xlim([-zoom_factor, zoom_factor])
ax.set_ylim([-zoom_factor, zoom_factor])
ax.set_zlim([-zoom_factor, zoom_factor])

Animation with FuncAnimation

from matplotlib.animation import FuncAnimation

def update(frame):
    # Calculate current time
    current_second = frame / fps

    # Query audio features
    beat_intensity = get_beat_intensity(current_second, beat_times)
    loudness = get_loudness_at_time(current_second, rms_times, rms_values)

    # Apply transformations
    # ... rotation, scaling, camera movement ...

    # Update scatter plot
    scatter._offsets3d = (x_new, y_new, z_new)
    scatter.set_alpha(alpha)

    # Update camera
    ax.view_init(elev=elevation, azim=azimuth)
    ax.set_xlim([-zoom, zoom])

    return scatter,

anim = FuncAnimation(fig, update, frames=total_frames, 
                    interval=1000/fps, blit=False)

Key points:

blit=False: Required for 3D plots (blitting doesn't work with 3D)
interval=1000/fps: Controls playback speed (33ms = 30 fps)
Each frame calls update() with the frame number

Performance Optimization

For multi-heart effects (I2, I3), we use lower point density:

density_multipliers = {
    'lower': 0.35,   # ~5,000 points per heart
    'low': 0.5,      # ~10,000 points
    'medium': 0.75,  # ~22,500 points
    'high': 1.0      # ~40,000 points
}

With 5 hearts at 40,000 points each = 200,000 points to render per frame. Using lower density reduces this to 25,000 points, making rendering feasible.

Putting It All Together: The Complete Pipeline

Audio Analysis (librosa)
- Input: Audio file (MP3, WAV, etc.)
- Output: JSON file with beat times, tempo, loudness, bass, onsets
Heart Generation (NumPy)
- Input: Density setting, formula coefficients
- Output: 3D point cloud (x, y, z coordinates)
Animation Rendering (Matplotlib)
- Input: Heart points, audio features JSON, effect configuration
- Process: For each frame, query audio features and apply transformations
- Output: Video file (MP4, no audio)
Audio Combination (FFmpeg)
- Input: Video file + original audio file
- Output: Final video with synchronized audio

Effect H9: Cuba to New Orleans - A Musical Journey

Duration: ~698 seconds (11.6 minutes)

H9 is an epic journey through a single piece of music, featuring strategic "through-heart" passages where the camera passes through the heart's core at key musical moments.

Technical Highlights

Dynamic Tempo Adaptation: Rotation speed adapts to tempo changes throughout the 11-minute piece
Through-Heart Passages: Camera zooms through the heart at specific timestamps, synchronized with musical transitions
Phase-Based Narrative: 14 distinct phases, each responding to different sections of the music
Multi-Feature Sync: Combines beats, tempo, loudness, bass, and onsets for comprehensive audio response

Implementation Details

# Phase 3: First through-heart passage (100-120s)
if current_second < 120.0:
    phase_t = (current_second - 100.0) / 20.0
    # Zoom through heart: 50 → 5 → 50
    zoom_factor = 50 - 45 * np.sin(np.pi * phase_t)
    # Camera passes through
    elevation = 20 + 10 * np.sin(2 * np.pi * phase_t)

The through-heart effect is achieved by zooming the camera from a distance (zoom=50) to very close (zoom=5) and back, creating the illusion of passing through the heart.

Effect I2: Five Hearts - Comprehensive Audio Feature Synchronization

Duration: Matches audio file length

I2 demonstrates multi-heart visualization where each heart responds to a different audio feature, creating a visual symphony.

The Five Hearts

Heart 1 (Beats): Pulses on detected beats, magma colormap
Heart 2 (Tempo): Rotation speed adapts to tempo, YlOrRd colormap
Heart 3 (Loudness): Scales with RMS energy, Blues colormap
Heart 4 (Bass): Brightness responds to bass, Greens colormap
Heart 5 (Onsets): Pulses on musical events, Purples colormap

Technical Implementation

# Each heart gets its own scatter plot
scatter1 = ax.scatter(x1, y1, z1, c=colors1, cmap='magma', s=1, alpha=0.8)
scatter2 = ax.scatter(x2, y2, z2, c=colors2, cmap='YlOrRd', s=1, alpha=0.6)
# ... etc for hearts 3, 4, 5

# In update function, process each heart independently
for i, (scatter, x_orig, y_orig, z_orig) in enumerate(hearts):
    # Assign feature based on heart index
    feature_type = i % 5

    if feature_type == 0:  # Beats
        scale = 1.0 + 0.2 * beat_intensity
    elif feature_type == 1:  # Tempo
        tempo_factor = current_tempo / 75.0
        rotation_speed = tempo_factor
    # ... etc

    # Update this heart's scatter plot
    scatter._offsets3d = (x_new, y_new, z_new)

Camera Strategy

The camera switches between modes:

Multi-heart frame: Wide view showing all 5 hearts
Individual focus: Close-up on one heart at a time
Orbital motion: Camera orbits around the center

Effect I3: Birthday Celebration - 11 Hearts to 16 Hearts

Duration: Matches audio file length (typically ~60 seconds for "Happy Birthday")

I3 is a special celebration effect that transitions from 11 hearts to 16 hearts, with number displays (11, 16, 2025) appearing at strategic moments.

The Two-Phase Design

Phase 1 (0-50%): 11 hearts in circular formation

1 center heart + 5 inner circle + 5 outer circle
Each heart syncs to different audio features

Phase 2 (50-100%): 16 hearts in 4x4 grid

Smooth transition adds 5 more hearts
More complex interactions and patterns

Number Display

Numbers are displayed as text overlays using Matplotlib's text annotation:

# Show "11" during 11-heart phase
if current_second < phase5_end and current_second >= total_duration * 0.11:
    fig.text(0.5, 0.85, '11', 
             fontsize=72, ha='center', va='center',
             color='white', alpha=0.7, weight='bold')

Heart Positioning

def _get_heart_positions_11(self):
    """11 hearts: 1 center + 5 inner + 5 outer"""
    positions = [(0, 0, 0)]  # Center

    # Inner circle
    for i in range(5):
        angle = 2 * np.pi * i / 5
        x = 20 * np.cos(angle)
        z = 20 * np.sin(angle)
        positions.append((x, 0, z))

    # Outer circle
    for i in range(5):
        angle = 2 * np.pi * i / 5 + np.pi / 5
        x = 35 * np.cos(angle)
        z = 35 * np.sin(angle)
        positions.append((x, 0, z))

    return positions

Lessons Learned: The "Vibe Coding" Approach

This project evolved through what I call "vibe coding", an iterative, creative development process driven by prompts and experimentation rather than strict upfront planning.

The Prompt-Driven Development

Each effect started as a detailed prompt in Prompt.md describing:

Visual narrative (phases, camera movements, transitions)
Audio synchronization strategy
Technical requirements
Implementation notes

These prompts served as both specification and inspiration, allowing the code to evolve organically.

Key Learnings

Start Simple, Iterate Complex
- Effect A (simple rotation) → Effect I3 (16 hearts with number display)
- Each effect built on previous learnings
Audio Features Are Rich
- Initially used only beats
- Discovered tempo, loudness, bass, and onsets each add unique visual dimensions
- Combining multiple features creates more nuanced responses
Performance Matters
- 40,000 points per heart × 16 hearts = 640,000 points per frame
- Lower density (5,000 points) still looks great and renders 128× faster
- Always profile before optimizing
Modular Design Wins
- Base effect class with update(frame) method
- Audio sync functions reusable across effects
- Easy to create new effects by extending the base class
Automation Is Essential
- Build scripts handle: audio analysis → video generation → audio combination
- Saves hours of manual work
- Makes experimentation faster
Documentation as You Go
- Prompt.md captures design decisions
- Code comments explain "why" not just "what"
- Makes revisiting code months later much easier

The Creative Process

Listen to the music - Understand its structure, energy, and emotional arc
Design the narrative - Plan phases that match the music's journey
Map audio to visuals - Decide which features drive which visual properties
Implement and iterate - Code, render, watch, adjust, repeat
Refine timing - Fine-tune phase boundaries and transitions
Optimize performance - Balance quality and render time

This process is more art than science, it requires intuition, experimentation, and patience.

Demo Videos

See these effects in action:

H9: Cuba to New Orleans - An 11-minute musical journey with through-heart passages
I2: Five Hearts - Five hearts, each dancing to different audio features
I3: Birthday Celebration - 11 hearts transform to 16 hearts with number displays

Conclusion

This project demonstrates how mathematics, signal processing, and visualization can combine to create something beautiful. The technical stack, NumPy for math, librosa for audio, Matplotlib for visualization, FFmpeg for video processing, is powerful yet accessible.

The real magic isn't in any single technology, but in how they work together:

Mathematics provides the shape
Audio analysis provides the rhythm
Synchronization provides the connection
Visualization provides the beauty

Whether you're interested in parametric equations, audio signal processing, or creative coding, there's something here to explore. The code is open source, the techniques are documented, and the possibilities are endless.

Next Steps:

Explore the codebase: GitHub Repository
Try creating your own effect
Analyze your favorite music
Make something beautiful

Created with Python, mathematics, and a passion for making music visible.

Create Synthetic Data - A Comprehensive Guideline

Vu Hung Nguyen (Hưng) — Sun, 09 Nov 2025 06:24:05 +0000

Overview
This document will guide you how to create synthetic data using Python, Cursor, to solve the problem of "being hungry for data" when real data is not available.

What is Synthetic Data?
Synthetic data is artificially generated data that mimics the statistical properties of real-world data. It is often used in scenarios where real data is scarce, sensitive, or expensive to obtain. Synthetic data can be used for testing, training machine learning models, and validating algorithms without compromising privacy or security.

Why Use Synthetic Data?
Privacy: Synthetic data can be generated without using any real personal information, making it a safer alternative for testing and development.
Cost-Effective: Generating synthetic data can be more cost-effective than collecting and maintaining real datasets.
Flexibility: Synthetic data can be tailored to specific requirements, allowing for the creation of diverse datasets that cover various scenarios.
Scalability: Synthetic data can be generated in large volumes, making it suitable for big data analytics.
Methodology
Python faker library is used to generate synthetic data.
Probabilistic approaches are employed to ensure the synthetic data closely resembles real-world data distributions.
Machine learning techniques can be applied to refine the synthetic data generation process.
Neural networks can be utilized to create more complex and realistic synthetic datasets, such as GAN (Generative Adversarial Networks)
Notes:

Translate a dataset from one language to another language can be a good choice
Expand or extend an existing dataset by generating synthetic samples based on the original data distribution.
For example, IoT sensor datasets can be extended by:

Generating more time series data points following observed patterns
Adding noise and anomalies for robustness testing
Simulating different environmental conditions
Creating multi-sensor correlation scenarios
Example Synthetic Data Generation Project
Define the features and structure of the synthetic datasets to be generated, do it manually, save it to FEATURES.md.

Example Prompt
Help me create a Python script that generates synthetic data for stock prices.

Refer to FEATURES.md for the fields to include: date, open, high, low, close, adjusted close, and volume.

Folder Structure
The folder structure is as follows:

synthetic-data/
├── datasets/
│ ├── small/
│ ├── medium/
│ ├── large/
│ ├── README.md
│ ├── FEATURES.md
│ └── .gitignore
├── scripts/
│ ├── generate_datasets.py
│ ├── compress_datasets.py
│ ├── README.md
│ └── .gitignore
├── requirements.txt
└── README.md
└── Makefile
└── .gitignore
data: where synthetic data will be stored
raw: raw synthetic data files
processed: processed synthetic data files
scripts: contains the Python script to generate synthetic data
README.md: How to install and run the script using uv with virtual enviroment named .venv
FEATURES.md: Document the features of the synthetic data generation process
requirements.txt: List of Python dependencies
README.md Structure
Overview & Purpose
Prerequisites (Python version (3.9+), libraries)
Installation Instructions (using uv with .venv)
Quick Start Guide
Basic usage examples
Common workflows
Configuration Options
Conclusion
Objectives of the Synthetic Datasets
Provide ready-to-use datasets to demonstrate ML workflows
Cover supervised, unsupervised, and semi-supervised learning (and suggest more options if any)
Support task types:
classification,
regression,
clustering
time-series forecasting: In this project, we focus on generating stock prices data
anomaly detection
recommendation systems
graph analysis
sentiment analysis
Note: Implement all these tasks if possible, they will be needed for comprehensive ML demonstrations.

Support a range of dataset sizes and feature counts
--size Options (Number of Samples)
small: 1,000 – 10,000
medium: 10,000 – 100,000
large: 100,000 – 1,000,000
extra large: 1,000,000 – 10,000,000
Feature targets
Features: 5 – 50: Number of features/columns in the dataset to generate. Do not set if FEATURES.md is present
Classes: 2 – 10 (classification)
Clusters: 2 – 10 (clustering)
Dataset format
CSV: Comma-separated values for easy import into various tools
Optionally, support for compressed formats like .csv.gz for large datasets
Encoding: UTF-8 to ensure compatibility
Example Run Command
python scripts/generate_datasets.py
--task classification
--size small
--num-samples 5000
--num-classes 3
--random-state 2025

scripts/generate_datasets.py Parameters
-t, --task: Type of machine learning task (classification, regression, clustering, etc.)
-s, --size: Size of the dataset to generate (small, medium, large, extra large)
-n, --num-samples: Number of samples/rows in the dataset
-f, --num-features: Number of features/columns in the dataset (if not using FEATURES.md)
-c, --num-classes: Number of classes (for classification tasks)
-k, --num-clusters: Number of clusters (for clustering tasks)
--random-state: Seed for random number generation to ensure reproducibility
--output-format: Format of the output dataset (CSV, CSV.GZ). Default is CSV
--output-dir: Directory to save the generated datasets. Default is datasets/
Note: When using --size, the script automatically determines the number of samples within the specified range. Use --num-samples to override with an exact number.

Makefile targets
make help # List available targets
make create-all # Generate representative datasets across tasks and sizes
make compress-all # Compress all CSV datasets (creates .csv.gz)
make clean # Delete all CSV files in datasets/
make clean-gzip # Delete all .csv.gz files in datasets/
make test
make sample # Generate small sample datasets for testing
make visualize # Create visualizations of dataset distributions
Required libraries
faker: For generating fake data such as names, addresses, emails, etc.
pandas: For data manipulation and analysis
scikit-learn: For generating datasets with specific characteristics
tensorflow or pytorch: For advanced synthetic data generation using neural networks
You can decide what libraries to use based on your specific needs and the complexity of the synthetic data you want to generate.

FEATURES.md Example
Features of Synthetic Data Generation of stock prices

Synthetic Data Features
The synthetic data features include:

Feature Name Description Data Type Example Values
Date Date of the stock price record Date 2015-03-31
Open Opening price of the stock Float 0.555
High Highest price of the stock Float 0.595
Low Lowest price of the stock Float 0.53
Close Closing price of the stock Float 0.565
Adj Close Adjusted closing price of the stock Float 0.565
Volume Trading volume of the stock Integer 4816294
Sample data
Date,Open,High,Low,Close,Adj Close,Volume
2015-03-31,0.555,0.595,0.53,0.565,0.565,4816294
2015-04-01,0.575,0.58,0.555,0.565,0.565,4376660
2015-04-02,0.56,0.565,0.535,0.555,0.555,2779640
Final Notes
R is a strong alternative to Python for synthetic data generation
Combine with LLMs to create more context-aware synthetic data is a promising direction, tailor your prompts
faker can be replaced by using LLM API calls to generate more realistic and diverse synthetic data samples.

Write a Research Proposal in 2 Hours, Not a Day! ⏱️

Vu Hung Nguyen (Hưng) — Thu, 06 Nov 2025 22:28:08 +0000

With help of AI, you can draft a solid research proposal in just a couple of hours instead of days. Here's how:

Let's say, we need to write a research proposal on NLP (Natural Language Processing), classifications of social media posts.

Step 1: Come up with some research ideas
Open Perplexity Comet, browse aclanthology.org and search for the keywords "social media"
Add more keywords if needed like GNN, multimodal, sentiment analysis, misinformation, disinformation, BERT, transformers, etc.

Notes:

Browse more sources like ACM NLP conference papers, Google Scholar, ScienceDirect, etc if needed.

Open all the papers on new tabs in Comet. Now I have 40 papers to read through, not manually, but with AI assistance!

Talk to "Comet" with a prompt: Research all open tabs and give me 10 research questions about classifications of social media posts. Cite the sources.

Step 2: Narrow down to 3 research ideas
Read through all 10 research ideas from Comet and pick 3 that I like the most.
Manually refine the 3 research ideas to make them more specific.
Talk the Comet again with a prompt:

Suggest me a research proposal title and abstract based on the following 3 research questions:

[Refined Research Question 1]
[Refined Research Question 2]
[Refined Research Question 3]

Step 3: Prepare a working directory
The folder structure looks like this:

research-proposal/
├── main.tex
├── Makefile
├── styles/. # User-defined LaTeX styles, overleaf templates, etc
├── references.bib # Bibtex file for references with abstract field included
├── refereneces/ # Downloaded papers go here, not mandatory
└── samples/ # Sample research proposals in LaTeX format for reference
Step 4 Prepare references.bib
Use Comet to extract Bibtex entries from all the papers I opened in Step 1.
The next magic starts here:

Write the research proposal
Open Cursor and use the following prompt to write the research proposal in one go:

Help me write a research proposal.

Save your response to main.tex

Create a Makefile to compile the LaTeX document with targets:

all: compile the document
pdf: compile to PDF
clean: remove auxiliary files
bib: compile the bibliography
view: open the compiled PDF
Title: {}

Research questions:

[Refined Research Question 1]
[Refined Research Question 2]
[Refined Research Question 3]
The structure o the research proposal should include the following sections:

Background
Current Research Landscape and Related Work
Research Motivation
Research Questions: Include the 3 research questions above
Methodology
Requirements
Timeline
References: Use the Bibtex entries from references.bib
Requirements:

Only cite the papers from the references.bib file, don't make up any citations.
Compiled PDF file should be less than 6 pages.
Tone should be formal and academic.
Methodology section should explain how I plan to answer the research questions.
Methodology section should include a diagram illustrating the research framework using LaTeX packages like tikz
Requirements section should list the hardware, software, datasets, and other resources needed for the research.
Timeline section should include a Gantt chart showing the timeline of the research activities over 36 months, with milestones and deliverables using LaTeX packages like pgfgantt
make sure make pdf command works without errors.
Additional requirements:

Refer to samples/research-proposal1.tex and samples/*.tex for formatting and structure guidance.
Step 5: Humanize and finalize
Humanize the text. I use stealthwriter or naturalwrite
Read through the generated main.tex file and make necessary edits to improve clarity, coherence, and flow.

Using Coding Agents for Smarter Research Citation Management

Vu Hung Nguyen (Hưng) — Thu, 06 Nov 2025 07:14:03 +0000

As researchers and developers, we often rely on tools like Zotero or Mendeley to manage our citations. They’re great for collecting and organizing references, but I’ve found them limited when it comes to searching and extracting insights from saved citations.

Over time, I’ve developed a more flexible workflow that combines traditional reference management with coding agents (like Cursor or Copilot) to make literature organization smarter and more automated.

My Workflow

Here’s how I set it up:

I create a single .bib file to store all references.

Each entry includes the paper’s download link, abstract, keywords, and notes—usually a short summary or reason for citation.
All downloaded papers are stored in a separate folder, ideally organized by topic.
For quick exploration, I use coding agents (such as Cursor or GitHub Copilot) to search and extract information directly from the .bib file.

This works especially well if the .bib file contains abstracts, keywords, and short notes—even without full-text access.
For deeper retrieval, I extend the approach using Retrieval-Augmented Generation (RAG).

This allows the coding agent to access both the .bib file and the full-text papers I’ve downloaded. Essentially, the agent "reads" from my personal library instead of querying the open web.
When prompting, I always instruct the agent to rely only on the saved citations (and downloaded papers, if available).

The response must include source references. This minimizes AI hallucination and ensures outputs are grounded in verified material.

Why This Works

This approach gives me:

Full control over citation context and metadata
Local, reproducible research environment
Powerful semantic search using AI tools
Less risk of fabricated or irrelevant information

If I only need to summarize main ideas across papers, storing abstracts in the .bib file is enough.

When I need to refer to conclusions or methodology in detail, I make sure the full paper is downloaded and indexed.

This workflow blends classic academic management with modern AI-driven retrieval—perfect for researchers who want to integrate intelligent automation without losing academic rigor.

Advanced Prompt Techniques for the Next Level of Vibe Coding

Vu Hung Nguyen (Hưng) — Wed, 08 Oct 2025 13:39:56 +0000

Introduction

In modern software engineering, prompt engineering for AI coding assistants (Copilot, Cursor, etc.) is rapidly maturing. Through three of my open-source projects—CodeGlow, Marlinga, and PyTorch Mastery—I've systematically experimented with advanced prompting strategies. Below, I distill actionable insights, struggles, and specific tactics from real-world GitHub repos, issues, and PRs that can level up your vibe coding workflow.

1. Project Contexts & Summaries

CodeGlow: A cross-language code beautifier focused on rapid formatting for Python, Java, and JavaScript, optimized for copying into rich-text editors like MS Word.
Marlinga: A fictional Martian colony translator, mixing English and conlang vocabulary, requiring creative prompts to bridge code, story, and UX logic.
PyTorch Mastery: A learning journey in deep learning, emphasizing best practices in code modularity, policy enforcement via Copilot, and educational template generation.[1][2]

2. Writing Effective Prompts for Copilot & Cursor

Key Techniques:

Modular Instruction Policies ([[CodeGlow PRs & Issues]]):[3][4][5][6]
- Place .github/copilot-instructions.md in the root or organize “instruction modules” by topic (e.g., Next.js, RTF export, copy-to-clipboard).
- Tip: Explicitly state, “Use OOP for all major components,” to bias Copilot towards maintainable class-based patterns.
Prompting for Helper Functions & Templates ([PyTorch Mastery PR #61]):
- “Use helper functions for all non-trivial logic, with type hints and short docstrings.”
- “Prefer @dataclass configs over ad hoc dicts for parameter management.”
Standardized Alias and Library Prompts ([PyTorch Mastery PR #51]):
- “Always import torch.nn.functional as F and reference as such for all activation and loss.”
- Encourage Copilot/Cursor to echo community conventions; e.g., “Apply sns.set_style('darkgrid') for model visualizations.”
User Story-Driven Prompts ([CodeGlow User Story Issue]):[7]
- “Summarize requirements as user stories, then prompt for modular code matching each story.”
Instructional Prompts for UI/UX ([CodeGlow/Marlinga Issues/PRs]):
- “Enforce explicit dark/light toggle as a user-selectable setting.”
- “Add footer linking Github and LinkedIn—Copilot should not hardcode URLs.”

3. Innovative Approaches & Lessons Learned

Modular Prompt Policies Lead to Modular Code:
- Projects with granular Copilot instructions (split by topic) saw clearer and more reusable code.
Prompting for Validation Infrastructure ([PyTorch Mastery]):
- Writing, “Create validate_code_style.py to audit for OOP/helper function ratios,” let Copilot generate automation for code review.
Policy Compliance Tracking:
- Prompt-assisted development improved helper function compliance from 30% (target) to 57% (actual) [PR #61].

4. Prompt Effectiveness: Reflections & Struggles

Prompt Drift Is Real: Without sustained policy files, “verbal” instructions buried in issues/PRs quickly get lost—leading to Copilot code regressions (e.g., GravityScript).
Explicit Examples Drive Accuracy: Adding positive and negative code examples in Copilot instruction files improved reliability.
Manual “Prompt Refactoring” Yields Results: Rewriting instructions to clarify roles (class vs. function, what to refactor, what to leave dynamic) directly impacted code intelligibility and review overhead.

5. Advanced Tips for Senior Vibe Coders

Centralize Prompt Policies: Store in .github/copilot-instructions/ and make modular; reference them in onboarding docs.
Use JSON or XML for Data Definitions: Standardizing on these formats for all prompt-related data empowers Copilot/Cursor to better infer schemas and serialization rules.
Explicit Pipeline Prompts: Rather than vague instructions, dictate, e.g., “After formatting, output in both JSON and XML; update docs automatically.”
Feedback-Driven Prompt Iteration: Routinely collect Copilot feedback via PR comments/issues and bake lessons into future instruction updates.
Enforce Documentation via Prompts: “Every function requires a docstring and type hints—reject PRs without both.”

Conclusion

Scaling “vibe coding” to production and team contexts means you control not only the code—but the instructional context Copilot and Cursor see. Modularity, clarity, and explicitness in prompts aren’t just for the AI—they’re for your team, your future self, and robust engineering velocity.

What advanced prompt tactics have leveled up your Copilot experience? Share your own in the comments or fork any of my [featured repos] for more!

References & Deep Dives:

[CodeGlow PR: Copilot instruction policy modularization][3]
[PyTorch Mastery: OOP and helper function prompt policy][1]
[hf-transformer-trove: Visualization set-up Copilot policy][2]
Issues and PRs on Copilot policies, user stories, & UX-driven prompting

1,
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

FFmpeg Tutorial: Creating Professional Videos with Advanced Filtering and GPU Acceleration

Vu Hung Nguyen (Hưng) — Wed, 01 Oct 2025 12:21:37 +0000

FFmpeg Tutorial: Creating Professional Videos with Advanced Filtering and GPU Acceleration

Master the art of video processing with FFmpeg: from basic operations to complex video looping, GPU acceleration, and automated video creation pipelines.

Introduction
Getting Started with FFmpeg
Basic Video Operations
Advanced Video Filtering
GPU Acceleration on Mac Silicon
Creating Looped Videos
Video Processing Pipeline
Real-World Examples
Best Practices
Troubleshooting

Introduction

FFmpeg is the Swiss Army knife of video processing - a powerful, open-source multimedia framework that can handle virtually any video or audio format. Whether you're creating YouTube content, processing surveillance footage, or building automated video pipelines, FFmpeg provides the tools you need to manipulate media files with precision and efficiency.

In this comprehensive tutorial, we'll explore advanced FFmpeg techniques used in real-world video production pipelines, including GPU acceleration, complex filtering, and automated video creation workflows.

Getting Started with FFmpeg

Installation on macOS

For Mac users, especially those with Apple Silicon (M1/M2/M3), FFmpeg can be installed via Homebrew:

# Install FFmpeg with hardware acceleration support
brew install ffmpeg

# Verify installation and check available encoders
ffmpeg -encoders | grep videotoolbox

Basic Command Structure

FFmpeg commands follow this general pattern:

ffmpeg [global options] -i input_file [input options] [output options] output_file

Basic Video Operations

1. Video Format Conversion

# Convert MP4 to AVI
ffmpeg -i input.mp4 output.avi

# Convert with specific codec
ffmpeg -i input.mp4 -c:v libx264 -c:a aac output.mp4

2. Video Resizing

# Resize to specific dimensions
ffmpeg -i input.mp4 -vf scale=1920:1080 output.mp4

# Resize maintaining aspect ratio
ffmpeg -i input.mp4 -vf scale=1920:-1 output.mp4

# Resize with specific resolution presets
ffmpeg -i input.mp4 -vf scale=1280:720 output_hd.mp4  # HD
ffmpeg -i input.mp4 -vf scale=1920:1080 output_fhd.mp4 # Full HD
ffmpeg -i input.mp4 -vf scale=640:480 output_sd.mp4    # SD

3. Removing Audio from Video

# Remove audio track
ffmpeg -i input.mp4 -c:v copy -an output_no_audio.mp4

# Extract audio only
ffmpeg -i input.mp4 -vn -c:a copy output_audio.aac

4. Trimming Videos

# Trim to first 4 seconds
ffmpeg -i input.mp4 -t 4 output_trimmed.mp4

# Trim from 10 seconds to 20 seconds
ffmpeg -i input.mp4 -ss 10 -t 10 output_trimmed.mp4

# Trim from specific time to end
ffmpeg -i input.mp4 -ss 00:01:30 output_from_1min30sec.mp4

Advanced Video Filtering

1. Complex Filter Graphs

FFmpeg's filter_complex allows you to chain multiple operations:

# Scale and reverse video
ffmpeg -i input.mp4 -filter_complex "[0:v]scale=1920:1080,reverse[v]" -map "[v]" output.mp4

2. Video Splitting and Concatenation

# Split video into two streams, reverse one, then concatenate
ffmpeg -i input.mp4 -filter_complex "
  [0:v]split=2[v1][v2];
  [v2]reverse[v2_rev];
  [v1][v2_rev]concat=n=2:v=1:a=0[v_cycle]
" -map "[v_cycle]" output_forward_reverse.mp4

3. Logo Overlay

# Add logo to bottom-left corner
ffmpeg -i video.mp4 -i logo.png -filter_complex "
  [0:v][1:v]overlay=10:H-h-10
" output_with_logo.mp4

GPU Acceleration on Mac Silicon

One of the most significant advantages of modern Macs is the built-in hardware acceleration. Using GPU acceleration can provide up to 8.5x faster encoding compared to CPU-only processing.

Enabling Hardware Acceleration

# Use Apple's hardware encoder for H.264
ffmpeg -i input.mp4 -c:v h264_videotoolbox -c:a aac output.mp4

# Use hardware encoder for HEVC/H.265
ffmpeg -i input.mp4 -c:v hevc_videotoolbox -c:a aac output.mp4

# With quality settings
ffmpeg -i input.mp4 -c:v h264_videotoolbox -q:v 50 -c:a aac output.mp4

Performance Comparison

Method	Encoding Speed	CPU Usage	Quality
Software (libx264)	1x	High	Excellent
Hardware (videotoolbox)	8.5x	Low	Good

Creating Looped Videos

Creating seamless looped videos is essential for background content, music videos, and ambient videos. Here are several approaches:

1. Simple Video Looping

# Loop video 5 times
ffmpeg -stream_loop 5 -i input.mp4 -c copy output_looped.mp4

# Infinite loop (until audio ends)
ffmpeg -stream_loop -1 -i input.mp4 -i audio.mp3 -c copy -shortest output.mp4

2. Forward-Reverse Looping

This creates a seamless loop by playing the video forward, then in reverse:

# Method 1: Single command with complex filter
ffmpeg -i input.mp4 -filter_complex "
  [0:v]split=2[v1][v2];
  [v2]reverse[v2_rev];
  [v1][v2_rev]concat=n=2:v=1:a=0[v_cycle];
  [v_cycle]loop=loop=-1:size=1:start=0[v_looped]
" -map "[v_looped]" output_seamless_loop.mp4

3. Two-Step Approach (More Reliable)

# Step 1: Create forward-reverse cycle
ffmpeg -i input.mp4 -filter_complex "
  [0:v]split=2[v1][v2];
  [v2]reverse[v2_rev];
  [v1][v2_rev]concat=n=2:v=1:a=0[v_cycle]
" -map "[v_cycle]" -t 16 video_cycle.mp4

# Step 2: Loop the cycle to match audio duration
ffmpeg -stream_loop -1 -i video_cycle.mp4 -i audio.mp3 \
  -c:v h264_videotoolbox -c:a aac -shortest output.mp4

# Clean up
rm video_cycle.mp4

Video Processing Pipeline

Automated Video Creation Workflow

Here's a complete pipeline for creating professional videos:

#!/bin/bash
# Complete video processing pipeline

# Step 1: Prepare video (remove sound, resize, add logo)
ffmpeg -y -i input.mp4 \
  -vf "scale=1920:1080,overlay=10:H-h-10:enable='between(t,0,inf)'" \
  -i logo.png \
  -c:v h264_videotoolbox -an \
  video_prepared.mp4

# Step 2: Create seamless loop
ffmpeg -y -i video_prepared.mp4 \
  -filter_complex "
    [0:v]split=2[v1][v2];
    [v2]reverse[v2_rev];
    [v1][v2_rev]concat=n=2:v=1:a=0[v_cycle]
  " \
  -map "[v_cycle]" -t 16 video_cycle.mp4

# Step 3: Combine with audio
ffmpeg -y -stream_loop -1 -i video_cycle.mp4 \
  -i concatenated_audio.mp3 \
  -c:v h264_videotoolbox -c:a aac -shortest \
  final_output.mp4

# Cleanup
rm video_cycle.mp4

Makefile Integration

# Makefile for automated video processing
OUTPUT_NAME ?= my-video
VIDEO_RESOLUTION ?= HD

all: $(OUTPUT_NAME).mp4

$(OUTPUT_NAME).mp4: video_prepared.mp4 audio_files/
    @echo "Creating final video..."
    @./combine_video_audio.sh --output-name $(OUTPUT_NAME)

video_prepared.mp4: input.mp4
    @echo "Preparing video..."
    @./prepare_video.sh --resolution $(VIDEO_RESOLUTION)

clean:
    @rm -f *.mp4 *.mp3
    @echo "Cleanup completed"

Real-World Examples

Example 1: Waterfall Background Video

# Create a 2.5-hour waterfall video with music
ffmpeg -y \
  -i "Ban_Gioc_Waterfall.mp4" \
  -i "concatenated_audio.mp3" \
  -filter_complex "
    [0:v]scale=1920:1080,setpts=PTS-STARTPTS[video_scaled];
    [video_scaled]split=2[v1][v2];
    [v2]reverse[v2_rev];
    [v1][v2_rev]concat=n=2:v=1:a=0[v_cycle];
    [v_cycle]loop=loop=-1:size=1:start=0[v_looped]
  " \
  -map "[v_looped]" \
  -map 1:a \
  -c:v h264_videotoolbox \
  -c:a aac \
  -shortest \
  -r 24 \
  "waterfall_music_video.mp4"

Example 2: Batch Video Processing

#!/bin/bash
# Process multiple videos with GPU acceleration

for video in *.mp4; do
    echo "Processing $video..."
    ffmpeg -y -i "$video" \
      -vf "scale=1920:1080,crop=1920:1080:0:0" \
      -c:v h264_videotoolbox \
      -c:a aac \
      -t 4 \
      "${video%.*}_processed.mp4"
done

Example 3: YouTube-Optimized Video

# Create YouTube-optimized video with chapters
ffmpeg -y \
  -i video.mp4 \
  -i audio.mp3 \
  -c:v h264_videotoolbox \
  -c:a aac \
  -b:a 128k \
  -movflags +faststart \
  -metadata title="My Video Title" \
  -metadata description="Video description" \
  youtube_ready.mp4

Best Practices

1. Performance Optimization

Always use GPU acceleration when available (h264_videotoolbox on Mac)
Use appropriate quality settings (q:v 50 for good quality/size balance)
Process in chunks for very large files
Use shortest when combining video and audio of different lengths

2. Quality Settings

# High quality (larger file)
ffmpeg -i input.mp4 -c:v h264_videotoolbox -q:v 20 output.mp4

# Balanced quality/size
ffmpeg -i input.mp4 -c:v h264_videotoolbox -q:v 50 output.mp4

# Smaller file size
ffmpeg -i input.mp4 -c:v h264_videotoolbox -q:v 60 output.mp4

3. Error Handling

# Always use -y to overwrite output files
ffmpeg -y -i input.mp4 output.mp4

# Check for errors in scripts
if [ $? -ne 0 ]; then
    echo "FFmpeg failed!"
    exit 1
fi

4. Memory Management

# For large files, process in segments
ffmpeg -i input.mp4 -ss 00:00:00 -t 00:05:00 -c copy segment1.mp4
ffmpeg -i input.mp4 -ss 00:05:00 -t 00:05:00 -c copy segment2.mp4

Troubleshooting

Common Issues and Solutions

"No such file or directory"
- Check file paths and permissions
- Ensure input files exist
"Codec not found"
- Install FFmpeg with full codec support
- Use brew install ffmpeg on macOS
High CPU usage
- Enable GPU acceleration with h264_videotoolbox
- Use preset fast for faster encoding
Audio/video sync issues
- Use shortest flag when combining streams
- Check frame rates with r parameter
Out of memory errors
- Process files in smaller chunks
- Use threads parameter to limit CPU usage

Debugging Commands

# Check video information
ffprobe -v quiet -print_format json -show_format -show_streams input.mp4

# Test encoding without output
ffmpeg -f lavfi -i testsrc=duration=1:size=1920x1080:rate=30 -f null -

# Monitor system resources
top -pid $(pgrep ffmpeg)

Conclusion

FFmpeg is an incredibly powerful tool for video processing, and with the right techniques, you can create professional-quality videos efficiently. The key is to:

Leverage hardware acceleration whenever possible
Use complex filters for advanced effects
Automate repetitive tasks with scripts and Makefiles
Optimize for your target platform (YouTube, social media, etc.)

Whether you're creating ambient videos, processing surveillance footage, or building automated video pipelines, FFmpeg provides the flexibility and power you need to achieve professional results.

Additional Resources

This tutorial is based on real-world video processing pipelines used in production environments. The examples and techniques shown here have been tested and optimized for performance and quality.

DEV Community: Vu Hung Nguyen (Hưng)

The Mathematics and Engineering Behind 3D Heart Animations Synchronized with Music

The Mathematics and Engineering Behind 3D Heart Animations Synchronized with Music

Introduction

The Key Ideas

The Mathematics: Parametric Heart Equations

The Core Equations

Implementation in Python

3D Rotation

The Sound Engineering: Audio Feature Extraction with Librosa

Audio Analysis Pipeline

Beat Detection

Dynamic Tempo Tracking

RMS Energy (Loudness)

Bass Extraction

Onset Detection

Output: JSON Feature File

Synchronizing Sound and Visuals

The Update Function

Audio Feature Queries

Applying Audio Features to Visuals

FFmpeg: Combining Video and Audio

Video Generation

Audio Combination

Automated Workflow

Python and Matplotlib: The Visualization Engine

Matplotlib's 3D Scatter Plot

Animation with FuncAnimation

Performance Optimization

Putting It All Together: The Complete Pipeline

Effect H9: Cuba to New Orleans - A Musical Journey

Technical Highlights

Implementation Details

Effect I2: Five Hearts - Comprehensive Audio Feature Synchronization

The Five Hearts

Technical Implementation

Camera Strategy

Effect I3: Birthday Celebration - 11 Hearts to 16 Hearts

The Two-Phase Design

Number Display

Heart Positioning

Lessons Learned: The "Vibe Coding" Approach

The Prompt-Driven Development

Key Learnings

The Creative Process

Demo Videos

Conclusion

Create Synthetic Data - A Comprehensive Guideline

Write a Research Proposal in 2 Hours, Not a Day! ⏱️

Using Coding Agents for Smarter Research Citation Management

My Workflow

Why This Works

Advanced Prompt Techniques for the Next Level of Vibe Coding

Introduction

1. Project Contexts & Summaries

2. Writing Effective Prompts for Copilot & Cursor

Key Techniques:

3. Innovative Approaches & Lessons Learned

4. Prompt Effectiveness: Reflections & Struggles

5. Advanced Tips for Senior Vibe Coders

Conclusion

FFmpeg Tutorial: Creating Professional Videos with Advanced Filtering and GPU Acceleration

FFmpeg Tutorial: Creating Professional Videos with Advanced Filtering and GPU Acceleration

FFmpeg Tutorial: Creating Professional Videos with Advanced Filtering and GPU Acceleration

Table of Contents

Introduction

Getting Started with FFmpeg

Installation on macOS

Basic Command Structure

Basic Video Operations

1. Video Format Conversion

2. Video Resizing

3. Removing Audio from Video

4. Trimming Videos

Advanced Video Filtering

1. Complex Filter Graphs

2. Video Splitting and Concatenation

3. Logo Overlay

GPU Acceleration on Mac Silicon

Enabling Hardware Acceleration