diff --git a/scripts/ai-heatmap.ipynb b/scripts/ai-heatmap.ipynb
index f2abada..9fe0599 100644
--- a/scripts/ai-heatmap.ipynb
+++ b/scripts/ai-heatmap.ipynb
@@ -432,7 +432,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.9.1"
   }
  },
  "nbformat": 4,
diff --git a/scripts/barchart_chatgpt_conversation.ipynb b/scripts/barchart_chatgpt_conversation.ipynb
new file mode 100644
index 0000000..2398841
--- /dev/null
+++ b/scripts/barchart_chatgpt_conversation.ipynb
@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "334981ef",
+   "metadata": {},
+   "source": [
+    "> The barchart visualization code was written by Babatunde Olaniyi **@tunescobabs**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "a9f313f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "convo_folder = r'C:\\Users\\user\\Downloads\\chat_gpt_history'\n",
+    "local_tz = 'Europe/London' "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2eae4b48",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "with open(f'{convo_folder}/conversations.json', 'r') as f:\n",
+    "    oai_convs = json.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "0c932505",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import datetime, timezone, timedelta\n",
+    "\n",
+    "oai_convo_times = []\n",
+    "for conv in oai_convs:\n",
+    "    # Given Unix timestamp\n",
+    "    unix_timestamp = conv['create_time']\n",
+    "\n",
+    "    # Convert to UTC datetime\n",
+    "    utc_datetime = datetime.fromtimestamp(unix_timestamp, tz=timezone.utc)\n",
+    "\n",
+    "    # Convert UTC datetime to local timezone\n",
+    "    pt_datetime = utc_datetime.astimezone(pytz.timezone(local_tz))\n",
+    "    oai_convo_times.append(pt_datetime)\n",
+    "\n",
+    "import matplotlib.dates as mdates\n",
+    "import matplotlib.patches as patches\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "from collections import Counter\n",
+    "\n",
+    "def create_year_heatmap(convo_times, year):\n",
+    "    # Convert convo_times to dates and filter for the given year\n",
+    "    just_dates = [convo.date() for convo in convo_times if convo.year == year]\n",
+    "\n",
+    "    date_counts = Counter(just_dates)\n",
+    "\n",
+    "    # Create a full year date range for the calendar\n",
+    "    start_date = datetime(year, 1, 1).date()\n",
+    "    end_date = datetime(year, 12, 31).date()\n",
+    "\n",
+    "    total_days = (end_date - start_date).days + 1\n",
+    "    date_range = [start_date + timedelta(days=i) for i in range(total_days)]\n",
+    "\n",
+    "    # Prepare data for plotting\n",
+    "    data = []\n",
+    "    for date in date_range:\n",
+    "        week = ((date - start_date).days + start_date.weekday()) // 7\n",
+    "        day_of_week = date.weekday()\n",
+    "        count = date_counts.get(date, 0)\n",
+    "        data.append((week, day_of_week, count))\n",
+    "\n",
+    "    weeks_in_year = (end_date - start_date).days // 7 + 1\n",
+    "\n",
+    "    # Plot the heatmap\n",
+    "    plt.figure(figsize=(15, 8))\n",
+    "    ax = plt.gca()\n",
+    "    ax.set_aspect('equal')\n",
+    "\n",
+    "    max_count_date = max(date_counts, key=date_counts.get)\n",
+    "    max_count = date_counts[max_count_date]\n",
+    "    p90_count = np.percentile(list(date_counts.values()), 90)\n",
+    "    for week, day_of_week, count in data:\n",
+    "        color = plt.cm.Greens((count + 1) / p90_count) if count > 0 else 'lightgray'\n",
+    "        rect = patches.Rectangle((week, day_of_week), 1, 1, linewidth=0.5, edgecolor='black', facecolor=color)\n",
+    "        ax.add_patch(rect)\n",
+    "\n",
+    "    # Replace week numbers with month names below the heatmap\n",
+    "    month_starts = [start_date + timedelta(days=i) for i in range(total_days)\n",
+    "                    if (start_date + timedelta(days=i)).day == 1]\n",
+    "    for month_start in month_starts:\n",
+    "        week = (month_start - start_date).days // 7\n",
+    "        plt.text(week + 0.5, 7.75, month_start.strftime('%b'), ha='center', va='center', fontsize=10, rotation=0)\n",
+    "\n",
+    "    # Adjustments for readability\n",
+    "    ax.set_xlim(-0.5, weeks_in_year + 0.5)\n",
+    "    ax.set_ylim(-0.5, 8.5)\n",
+    "    plt.title(\n",
+    "        f'{year} ChatGPT Conversation Heatmap (total={sum(date_counts.values())}).\\nMost active day: {max_count_date} with {max_count} convos.',\n",
+    "        fontsize=16\n",
+    "    )\n",
+    "    plt.xticks([])\n",
+    "    plt.yticks(range(7), ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'])\n",
+    "    plt.gca().invert_yaxis()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "ad7253ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter\n",
+    "\n",
+    "# Extract years from conversation times\n",
+    "years = [convo.year for convo in oai_convo_times]\n",
+    "\n",
+    "# Count the number of conversations per year\n",
+    "year_counts = Counter(years)\n",
+    "\n",
+    "# Prepare data for plotting\n",
+    "sorted_years = sorted(year_counts.keys())\n",
+    "counts = [year_counts[year] for year in sorted_years]\n",
+    "\n",
+    "# Create a DataFrame for Seaborn\n",
+    "import pandas as pd\n",
+    "data = pd.DataFrame({'Year': sorted_years, 'Conversations': counts})\n",
+    "\n",
+    "# Set Seaborn style\n",
+    "sns.set_theme(style=\"whitegrid\")\n",
+    "\n",
+    "# Create a bar chart\n",
+    "plt.figure(figsize=(12, 6))\n",
+    "palette = sns.color_palette(\"viridis\", len(sorted_years))  # Use a vibrant color palette\n",
+    "barplot = sns.barplot(\n",
+    "    x='Year',\n",
+    "    y='Conversations',\n",
+    "    data=data,\n",
+    "    palette=palette,\n",
+    "    edgecolor='black'\n",
+    ")\n",
+    "\n",
+    "# Add value labels to the bars\n",
+    "for bar in barplot.patches:\n",
+    "    barplot.annotate(\n",
+    "        format(bar.get_height(), ','),  \n",
+    "        (bar.get_x() + bar.get_width() / 2, bar.get_height()),\n",
+    "        ha='center',\n",
+    "        va='center',\n",
+    "        size=10,\n",
+    "        xytext=(0, 8),\n",
+    "        textcoords='offset points'\n",
+    "    )\n",
+    "\n",
+    "# Customize the chart\n",
+    "plt.title('Number of Conversations with ChatGPT by Year', fontsize=16, fontweight='bold')\n",
+    "plt.xlabel('Year', fontsize=12)\n",
+    "plt.ylabel('Number of Conversations', fontsize=12)\n",
+    "plt.xticks(fontsize=10)\n",
+    "plt.yticks(fontsize=10)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# Show the chart\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b0485d92",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}